Develop Reference

Multiple View Folders Based on URL parameter

I have developed an MVC5 application for one of our client. It works fine. Now we have more clients where all the functionalities are same, but the view is different for each client(Not only the layout, but the html structure itself is different in each view).
What I was doing to distinguish the clients is to provide different urls, adding a client identifier (because we need to identify the client even before login), and filtereing it in the RouteConfig as given below:
routes.MapRoute("ClientRoute", "{client}/{controller}/{action}/{id}",
new { controller = "Home", action = "Index", id =
UrlParameter.Optional },
new RouteValueDictionary
{
{ "client", "icici|federal|pnb|sbi" }
});
where the icici,federal,pnb and sbi are the valid clients.
and I could use this below code to distinguish the clients for any client specific logic.
var clientName = HttpContext.Current.Request.RequestContext.RouteData.Values["client"].ToString();
What I want is to have separate View folders for each client
Views (Default, should be taken from here if not found in other locations)
ICICI_Views
SBI_Views
FEDERAL_Views
PNB_Views
....
these folders will have the layout and cshtml files.
Any action having return View() or return View("viewname") should pick the corresponding views from the respected client folders.
Please help me if anyone know any solution to implement this (like configuring RouteConfig or DisplayModeProvider class, etc). I dont want to have a if-else check in each return view statement and specify the full path.
Thanks in advance :)

You can specify the path of the view while returning from action method, For example if the client is ICICI then return View("~/ICICI_Views/Home/Index.cshtml"); and if no client found you can use return View();
return View("~/ICICI_Views/Home/Index.cshtml");

Proper way to route to controllers in Umbraco ASP.NET / IApplicationEventHander vs ApplicationEventHandler vs RouteConfig.cs, RenderMvcController etc

I have a Solution structure like this:
MyApp.Core
--Properties
--References
--bin
--Events
|EventHandlers.cs
--Directory
--Controllers
|DirectoryController.cs
--Helpers
|ContextHelpers.cs
--Models
|DirectoryModel.cs
--AnotherSite
--Controllers
--Helpers
--Models
--Services
--Shared
--Controllers
|HomePageController.cs
--Helpers
|Extensions.cs
|app.config
|packages.config
MyApp.Umbraco
--Properties
--References
--bin
etc........
--Views
--Directory
--Partials
|DirectoryFilters.cshtml
|DirectoryBase.cshtml
|DirectoryHome.cshtml
|FDirectory.cshtml
|SDirectory.cshtml
--Partials
--Shared
|Base.cshtml
|Web.config
etc........
My Umbraco instance uses the models and controllers from my "Core" project. There is nested directory structure, because of multiple websites in one installation, in the "Core", and also in the "Views" directory in the Umbraco instance.
I am still fairly noob to .NET MVC, and I understand route hijacking, but the documentation for Umbraco's routing is slim. I have the following:
EventHandlers.cs
namespace MyApp.Core.Events
{
/// <summary>
/// Registers site specific Umbraco application event handlers
/// </summary>
public class MyAppStartupHandler : IApplicationEventHandler
{
public void OnApplicationInitialized(UmbracoApplicationBase umbracoApplication, ApplicationContext applicationContext)
{
}
public void OnApplicationStarted(UmbracoApplicationBase umbracoApplication, ApplicationContext applicationContext)
{
RegisterCustomRoutes();
}
public void OnApplicationStarting(UmbracoApplicationBase umbracoApplication, ApplicationContext applicationContext)
{
}
private static void RegisterCustomRoutes()
{
// Custom Routes
RouteTable.Routes.MapUmbracoRoute(
"FDirectory",
"fdirectory/{id}",
new
{
controller = "Directory",
action = "FDirectory",
id = UrlParameter.Optional
},
new PublishedPageRouteHandler(1000));
RouteTable.Routes.MapUmbracoRoute(
"SDirectory",
"sdirectory/{id}",
new
{
controller = "Directory",
action = "SDirectory",
id = UrlParameter.Optional
},
new PublishedPageRouteHandler(1001));
RouteTable.Routes.MapUmbracoRoute(
"HomePage",
"",
new
{
controller = "HomePage",
action = "Index",
id = UrlParameter.Optional
},
new PublishedPageRouteHandler(1002));
}
}
public class PublishedPageRouteHandler : UmbracoVirtualNodeRouteHandler
{
private readonly int _pageId;
public PublishedPageRouteHandler(int pageId)
{
_pageId = pageId;
}
protected override IPublishedContent FindContent(RequestContext requestContext, UmbracoContext umbracoContext)
{
if (umbracoContext != null)
{
umbracoContext = ContextHelpers.EnsureUmbracoContext();
}
var helper = new UmbracoHelper(UmbracoContext.Current);
return helper.TypedContent(_pageId);
}
}
}
DirectoryController.cs
namespace MyApp.Core.Directory.Controllers
{
public class DirectoryController : RenderMvcController
{
public DirectoryController() : this(UmbracoContext.Current) { }
public DirectoryController(UmbracoContext umbracoContext) : base(umbracoContext) { }
public ActionResult FDirectory(RenderModel model)
{
return CurrentTemplate(new DirectoryModel(model.Content));
}
public ActionResult SDirectory(RenderModel model)
{
return CurrentTemplate(new DirectoryModel(model.Content));
}
}
}
So Umbraco does not install with an App_Start folder. I would like to know what the best approach is for a multi-site installation of Umbraco for registering the routes to the controllers. My implementation works, but it seems like I shouldn't have to create actions for every single page I am going to have in a site, in every controller. I know Umbraco has its own routing, so using Umbraco concepts, ASP.NET MVC concepts, and whatever else is available, what is the best way to implement this type of solution structure? Should I even worry about using a RouteConfig.cs and create a App_Start directory? Or is what I am doing the best approach? Should I use IApplicationEventHandler or ApplicationEventHandler?
Also, I have to hard code the node ID's. I've read that there is a way to Dynamically? And example of this would be great.
Examples of the best way to implement a structured multi-site Umbraco MVC solution is what I am asking for I guess, in regards to routing the controllers, with some detail, or links to strong examples. I have searched and researched, and there are bits and pieces out there, but not really a good example like what I am working with. I am going to have to create a RouteMap for every single page I create at this point, and I don't know if this is the most efficient way of doing this. I even tried implementing a DefaultController, but didn't see the point of that when your solution is going to have multiple controllers.

I'm not entirely sure what you are trying to achieve with this, but I'll try to explain how it works and maybe you can clarify afterwards.
I assume you have the basics of Umbraco figured out (creating document types + documents based on the document types). This is how Umbraco is normally used and it will automatically do routing for you for each of these "content nodes" (documents) you create in a site.
So create a document named document1 and it will be automatically routed in your site at URL: http://localhost/document1. By default this document will be served through a default MVC controller and it will all take place behind the scenes without you having to do anything.
Route hijacking allows you to override this default behavior and "shove in" a controller that lets you interfere with how the request is handled. To use hijacking you create a RenderMvcController with the alias of your document type. That could be HomePageController : RenderMvcController.
This controller should have an action with the following signature:
public override ActionResult Index(RenderModel model)
In this action you are able to modify the model being sent to the view in any way you like. That could be - getting some external data to add on to the model or triggering some logic or whatever you need to do.
This is all automatically hooked up by naming convention and you will not have to register any routes manually for this to work.
The other type of Umbraco MVC controller you can create is a SurfaceController. This one is usually used for handling rendering of child actions and form submissions (HttpPost). The SurfaceController is also automatically routed by Umbraco and will be located on a "not so pretty" URL. However since it is usually really not used for anything but rendering child actions and taking form submits, it doesn't really matter what URL it is located at.
Besides these auto-routed controllers you are of course able to register your own MVC controllers like in any standard MVC website. The one difference though is that unlike a normal ASP.NET MVC website, an Umbraco site does not have the automagical default registration of controllers allowing the routing to "just work" when creating a new controller.
So if you want to have a plain old MVC controller render in an Umbraco site without it being related to a document/node in Umbraco, you would have to register a route for it like you would do in any other MVC site. The best way of doing that is to hook in and add it to the Routes using an ApplicationEventHandler class. That will automatically be triggered during application startup - essentially allowing you to do what you would normally do in App_Start.
Just to be clear though - if you plan on using data from Umbraco, you should not be using normal MVC controllers and should not require any manual route registration to be done. You usually want to render a template/view in context of a document/node created in Umbraco (where you can modify data/properties of the document) and then the route hijacking is the way to go.
From what it looks like, it could seem that the correct way to do what you are trying to do is to simply create two document types:
FDirectory and SDirectory
You click to allow both of these to be created in root and then you create documents called FDirectory and SDirectory and they will be automatically routed on these URLs. Creating a RenderMvcController's called FDirectoryController : RenderMvcController will then make sure it is used to hijack the routing whenever that page is requested.
If you're simply trying to set up a multi-site solution I would suggest you create a Website document type and create a node for each site you want, in the root of your Umbraco content tree. Right click each of these nodes and edit the hostname to be whatever you need it to be. This can also be some "child url" like /fdirectory or /sdirectory in case you need to test this on localhost without using multiple hostnames.
Hope this gives you the pointers needed, otherwise try to explain what you are trying to do and I'll see if I can refine my answer a bit!

MVC Restful routing and returning Views

My question is very similar to this one MVC Rest and returning views but the answer isn't working for me. I have implemented Restful Routing in my MVC application using (http://restfulrouting.com/).
When I want to add a new record the url is:
localhost/operations/1/exhibits/new
This calls the New action which returns New.cshtml as the view which contains a form. When the user submits the form and the Create action is called successfully on the Exhibits controller.
If the model state has errors I would like to return back to the New view with the date entered by the use still in place and show an error message (not implemented yet).
At present
return View("New", model)
sends back the data and renders the "New" view but the url changes to:
/localhost/operations/1/exhibits
I have checked the route values and the action being returned still is "create". I have navigation links that are driven by the action and controller values and the incorrect url means these don't get rendered properly.
Controller
public class ExhibitController : Controller
{
public ActionResult Index()
{
CreateExhibitViewModel model = new CreateExhibitViewModel();
return View(model);
}
public ActionResult New()
{
return View();
}
[HttpPost]
public ActionResult Create(MyModel model)
{
if(!ModelState.IsValid)
{
return View("New", model")
}
// Process my model
return RedirectToAction("Index");
}
}
View
#model RocketBook.Web.ViewModels.Exhibit.CreateExhibitViewModel
#{
Html.HttpMethodOverride(HttpVerbs.Put);
ViewBag.Title = "Operation " + ViewBag.OperationName;
}
<div class="panel panel-default">
<div class="panel-heading">
<h4>New Exhibit</h4>
</div>
<div class="panel-body">
<div class="col-lg-6 form-horizontal">
#using (var form = Html.Bootstrap().Begin(new Form("create", "exhibit").Id("newexhibit").Type(FormType.Horizontal).FormMethod(FormMethod.Post).WidthLg(4)))
{
#Html.AntiForgeryToken()
<fieldset>
<legend>Details</legend>
#Html.HiddenFor(m => m.OperationID)
#Html.HiddenFor(m => m.JobID)
#form.FormGroup().TextBoxFor(m => m.Barcode)
#form.FormGroup().TextBoxFor(m => m.ExhibitRef)
#form.FormGroup().TextBoxFor(m => m.ExhibitDescription)
#form.FormGroup().DropDownListFor(m => m.ClassificationGroupID, Model.ClassificationGroups).OptionLabel("")
#form.FormGroup().DropDownListFor(m => m.ClassificationID, Model.Classifications).OptionLabel("")
#form.FormGroup().DropDownListFor(m => m.ExhibitPriority, Model.EntityPriorities).OptionLabel("")
</fieldset>
<hr />
#(form.FormGroup().CustomControls(
Html.Bootstrap().SubmitButton().Style(ButtonStyle.Primary).Text("Add Exhibit")))
}
</div>
</div>
</div>

I continued this discussion on the RestfulRouting Github page at
https://github.com/stevehodgkiss/restful-routing/issues/76
For anyone who also finds this behaviour and is confused, don't be, it is in fact the correct behaviour. Here is an explanaition from Steve Hodgkiss creator of the RestfulRouting project for ASP.NET MVC
No that's expected, that's the path you go to when creating a model, and if something goes wrong it's only natural that it be halted there. When they pass validation they can move on...
A couple of solutions exist for distinguishing the URL. The HTTP Method used when calling
http://localhost/operations/1/exhibits
is a GET request and should call the Index action. If we have returned to this URL having had an error in the create action the HTTP method should be show as a POST. This can be accessed using
System.Web.HttpContext.Current.Request.HttpMethod
Another solution as suggested by Khalid is:
If you are using a ViewModel you could just flip a value on the ViewModel from inside the action. Since you are returning the model back in your Create action you can just touch a property. Might save you from having
System.Web.HttpContext.Current.Request.HttpMethod
lingering in your code.
Oh and if you put it on the viewmodel you can create a convention with a ActionFilter. If model == FlippyModel, just auto flip that property. If it fails, then that property will be true, if it passes you are moving on to the next view.

At first glance it looks like the OperationsId is not being resolved into the url / form action.
What happens when you first come to the New page is that the operationId is being passed in by ASP.NET MVC. ASP.NET MVC is being helpful by trying to find and using any old route values and plugging them into your route for you. Sounds confusing but let me explain by urls.
// url
/localhost/operations/1/exhibits/new
// on the view
Url.Action("create", "exhibits", new { /* operationId is implicit */ })
Next we do a POST to the create action.
// url
/localhost/operations/1/exhibits
// on the view
Url.Action("create", "exhibits", new { /* operationId is missing! */ })
The issue arises when you get sent back to this page because the action from above is missing the operationId. This is a symptom of the route value dictionary in ASP.NET MVC (I have no idea why it does this, but it does).
Solution:
I make all my routes explicit, don't lean on ASP.NET MVC to give you the implicit values, because it is just too hard to remember when to use them. Instead just get in the habit of always being explicit.
// on new the view
Url.Action("create", "exhibits", new { operationId = Model.OperationId })
// on the edit view
Url.Action("update", "exhibits", new { operationId = Model.OperationId, id = Model.Id })
This will work every time and you don't have to worry about whether the value you need is sitting in the route value dictionary.

How to implement custom controllers in Umbraco 6

I am having trouble getting my custom controllers to behave properly in an Umbraco MVC site. I can't work out how to pass custom models and use custom ActionResults. When I try to send a form the method is not being called. So a method like this
public ActionResult Home(string username, string password)
{
Debug.WriteLine("form");
var company = new Company();
return CurrentTemplate(company);
}
that should be called from a form like this but nothing happens.
#using (Html.BeginForm("Home","Login", FormMethod.Post, new {name = "logon"}))
{
<label>User name </label><input type="text" id="username"/><br/>
<label>Password </label><input type="password" id="password"/><br/>
<input type="submit" value="Here"/>
}
I know it is possible to override the default controller but is there any point in doing so?

Old post, but I thought I'd add my findings from a current project I'm working in.
For posts, as you're referring to in your form, you'd need a SurfaceController for most instances as #Digbyswift said.
HOWEVER - this is where I had the most trouble. I have a form that posts to another page, which displays results, and then displays that data on a view. I wanted to get away from using query strings and putting data in session, etc, since we're using MVC. This also allowed me to return a custom view that also used CurrentPage, which you need to have RenderModel as the model. We're going to need to set up a few things:
1) Create your controller, view, and document type. In this instance, I was dealing w/ "members", so I created a Member doc type, MemberController, etc.
2) On the view that's posting to the form:
<form method="post" action="member">
<div class="form-group">
<input type="text" id="query" name="query" class="form-control" placeholder="Member Company or State" />
</div>
<input type="submit" value="Search" class="button button-green" />
</form>
You could also define a custom route in a class that inherits from the ApplicationEventHandler class and register the route in the ApplicationStarted event, but this way we'll just override the Index action.
3) On the controller, MemberController
public class MemberController : RenderMvcController
{
[EnsurePublishedContentRequest(2303)] // 2303 is your node ID
public ActionResult Index(string query)
{
// your code - assign to ViewBag
return View("~/Views/Member.cshtml", this.CreateRenderModel(Umbraco.TypedContent(2303)));
}
}
private RenderModel CreateRenderModel(IPublishedContent content)
{
var model = new RenderModel(content, CultureInfo.CurrentUICulture);
//add an umbraco data token so the umbraco view engine executes
RouteData.DataTokens["umbraco-doc-request"] = model;
return model;
}
You DO NOT have to do this if you do not have any macros that need to rendered. In my case I had this view that inherited a _layout.
Custom MVC Routes in Umbraco
We have to do (2) things here. One is to make sure that we get the PublishedContentRequest.
The second part is to get the RenderModel object. I read a lot of articles in which your base model should inherit from RenderModel, and add in some default Umbraco constructors, but I didn't have very much luck with this.
Hope this helps somebody.

In Umbraco, every request is routed through the Umbraco.Web.Mvc.RenderMvcController but you can override this and the documentation is here.
However, I would suggest that if you feel you need to do this then you are possibly over-complicating your implementation. You can still use your approach to render ChildActions which can be given a model independent of the Umbraco page model. See here. This is great for things like rendering paged search results, document listings and content you want to be able to control in a controller. I use this approach a lot but always try and pass back a model centered around the IPublishedContent interface (e.g. IEnumerable<IPublishedContent> for a page listing), that way in the View, you can still have access to the Umbraco content and API from the View instead of having to implement too many of your own properties in a model.
When it comes to posting forms it's a little more tricky because you have two options:
As Dan Diplo says, you can use the Html.BeginUmbracoForm() approach; or
You can post back to a [HttpPost] action in the standard MVC way, i.e. Html.BeginForm().
The challenge with (2) is that because all requests are passed through Umbraco.Web.Mvc.RenderMvcController, you cannot tell a form which page to post to. You can only post to itself or a non-Umbraco-controlled action. You could for example let the form post back to the same page and have a second ChildAction specifically for the [HttpPost]. The issue with this is that it would catch all posts regardless of the form being posted from.
Personally, I use approach (1) in most standard forms where I need to interact with Umbraco directly, e.g. enquiries, uploads etc. and I use approach (2) when I need more control. But this generally needs a lot more thought.

Do you really mean you want a custom controller, or do you actually just want to create a form in Umbraco using MVC? If it's the latter then you need to use a surface controller ie. ensure your controller inherits from Umbraco.Web.Mvc.SurfaceController and has the suffix 'SurfaceController'.
public class MySurfaceController : Umbraco.Web.Mvc.SurfaceController
{
public ActionResult Index()
{
return Content("hello world");
}
}
You then need to use the custom Umbraco Html helper to create your form tags:
#using(Html.BeginUmbracoForm("CreateComment", "BlogPostSurface"))
{
//
}
See http://our.umbraco.org/documentation/Reference/Mvc/forms

MVC Razor Hidden input and passing values

I am pretty sure I am doing something wrong here. I have been developing a web app using MVC and Razor and I never thought of using the form element. Now so much has already been done with master pages and sub pages that it means restructuring most of our code in order to use form element and the would result in multiple form elements on a page.
That aside, in Asp.Net if I wanted to access any control in the C# code behind I could just give it an ID="SomeID" and a RUNAT="SERVER". Then in my code behind I could set its value and properties.
When I do this in Razor, I use lines like:
<input id="hiddenPostBack" runat="server" type="hidden" />
Why can't I access this in the controller? I want to detect a postback and set the value to false if it is the first time the page loads, and if not, then set the value to true. Then based on this, I will read it either server side or client side and do something.
My real question is, how do I "do something" both server side and client side given that I don't have a form element. I was under the impression that if I wanted to pass values from client to server and back, the easiest way to do this is with a hidden input. But I am just not getting how to accomplish this with MVC3 and razor.

A move from WebForms to MVC requires a complete sea-change in logic and brain processes. You're no longer interacting with the 'form' both server-side and client-side (and in fact even with WebForms you weren't interacting client-side). You've probably just mixed up a bit of thinking there, in that with WebForms and RUNAT="SERVER" you were merely interacting with the building of the Web page.
MVC is somewhat similar in that you have server-side code in constructing the model (the data you need to build what your user will see), but once you have built the HTML you need to appreciate that the link between the server and the user no longer exists. They have a page of HTML, that's it.
So the HTML you are building is read-only. You pass the model through to the Razor page, which will build HTML appropriate to that model.
If you want to have a hidden element which sets true or false depending on whether this is the first view or not you need a bool in your model, and set it to True in the Action if it's in response to a follow up. This could be done by having different actions depending on whether the request is [HttpGet] or [HttpPost] (if that's appropriate for how you set up your form: a GET request for the first visit and a POST request if submitting a form).
Alternatively the model could be set to True when it's created (which will be the first time you visit the page), but after you check the value as being True or False (since a bool defaults to False when it's instantiated). Then using:
#Html.HiddenFor(x => x.HiddenPostBack)
in your form, which will put a hidden True. When the form is posted back to your server the model will now have that value set to True.
It's hard to give much more advice than that as your question isn't specific as to why you want to do this. It's perhaps vital that you read a good book on moving to MVC from WebForms, such as Steve Sanderson's Pro ASP.NET MVC.

If you are using Razor, you cannot access the field directly, but you can manage its value.
The idea is that the first Microsoft approach drive the developers away from Web Development and make it easy for Desktop programmers (for example) to make web applications.
Meanwhile, the web developers, did not understand this tricky strange way of ASP.NET.
Actually this hidden input is rendered on client-side, and the ASP has no access to it (it never had). However, in time you will see its a piratical way and you may rely on it, when you get use with it. The web development differs from the Desktop or Mobile.
The model is your logical unit, and the hidden field (and the whole view page) is just a representative view of the data. So you can dedicate your work on the application or domain logic and the view simply just serves it to the consumer - which means you need no detailed access and "brainstorming" functionality in the view.
The controller actually does work you need for manage the hidden or general setup. The model serves specific logical unit properties and functionality and the view just renders it to the end user, simply said. Read more about MVC.
Model
public class MyClassModel
{
public int Id { get; set; }
public string Name { get; set; }
public string MyPropertyForHidden { get; set; }
}
This is the controller aciton
public ActionResult MyPageView()
{
MyClassModel model = new MyClassModel(); // Single entity, strongly-typed
// IList model = new List<MyClassModel>(); // or List, strongly-typed
// ViewBag.MyHiddenInputValue = "Something to pass"; // ...or using ViewBag
return View(model);
}
The view is below
//This will make a Model property of the View to be of MyClassModel
#model MyNamespace.Models.MyClassModel // strongly-typed view
// #model IList<MyNamespace.Models.MyClassModel> // list, strongly-typed view
// ... Some Other Code ...
#using(Html.BeginForm()) // Creates <form>
{
// Renders hidden field for your model property (strongly-typed)
// The field rendered to server your model property (Address, Phone, etc.)
Html.HiddenFor(model => Model.MyPropertyForHidden);
// For list you may use foreach on Model
// foreach(var item in Model) or foreach(MyClassModel item in Model)
}
// ... Some Other Code ...
The view with ViewBag:
// ... Some Other Code ...
#using(Html.BeginForm()) // Creates <form>
{
Html.Hidden(
"HiddenName",
ViewBag.MyHiddenInputValue,
new { #class = "hiddencss", maxlength = 255 /*, etc... */ }
);
}
// ... Some Other Code ...
We are using Html Helper to render the Hidden field or we could write it by hand - <input name=".." id=".." value="ViewBag.MyHiddenInputValue"> also.
The ViewBag is some sort of data carrier to the view. It does not restrict you with model - you can place whatever you like.

As you may have already figured, Asp.Net MVC is a different paradigm than Asp.Net (webforms). Accessing form elements between the server and client take a different approach in Asp.Net MVC.
You can google more reading material on this on the web. For now, I would suggest using Ajax to get or post data to the server. You can still employ input type="hidden", but initialize it with a value from the ViewData or for Razor, ViewBag.
For example, your controller may look like this:
public ActionResult Index()
{
ViewBag.MyInitialValue = true;
return View();
}
In your view, you can have an input elemet that is initialized by the value in your ViewBag:
<input type="hidden" name="myHiddenInput" id="myHiddenInput" value="#ViewBag.MyInitialValue" />
Then you can pass data between the client and server via ajax. For example, using jQuery:
$.get('GetMyNewValue?oldValue=' + $('#myHiddenInput').val(), function (e) {
// blah
});
You can alternatively use $.ajax, $.getJSON, $.post depending on your requirement.

First of all ASP.NET MVC does not work the same way WebForms does. You don't have the whole runat="server" thing. MVC does not offer the abstraction layer that WebForms offered. Probabaly you should try to understand what controllers and actions are and then you should look at model binding. Any beginner level tutorial about MVC shows how you can pass data between the client and the server.

You are doing it wrong since you try to map WebForms in the MVC application.
There are no server side controlls in MVC. Only the View and the
Controller on the back-end. You send the data from server to the client by
means of initialization of the View with your model.
This is happening on the HTTP GET request to your resource.
[HttpGet]
public ActionResult Home()
{
var model = new HomeModel { Greeatings = "Hi" };
return View(model);
}
You send data from client to server by means of posting data to
server. To make that happen, you create a form inside your view and
[HttpPost] handler in your controller.
// View
#using (Html.BeginForm()) {
#Html.TextBoxFor(m => m.Name)
#Html.TextBoxFor(m => m.Password)
}
// Controller
[HttpPost]
public ActionResult Home(LoginModel model)
{
// do auth.. and stuff
return Redirect();
}