Posted on Leave a comment


Our site needs to send emails to its users, for example when the user forgets the password. To do this comes to the rescue System.Net.Mail.SmtpClient class.

This class automatically uses the SMTP server settings stored in the Web.config file. You just have to add to that file the following tags inside the configuration tag:

 <smtp deliveryMethod="Network" from="mail_from">
 <network host="my_smtp_server" port="my_smtp_server_port" userName="user_name_smtp" password="password" clientDomain="my_domain" />


In the view Account/Login , you can see, bottom, on the left, the link to Account/ForgotPassword that is the page where the user can reset his password.

In the  controller Account, in the action post  “ForgotPassword” you make operational, removing them as a comment, the lines of code dedicated to password recovery.

In the file IdentityConfig.cs, in the function

public Task SendAsync(IdentityMessage message)

and replaced to the line

return Task.FromResult(0);

with the following lines of code

var sentFrom = ""
 System.Net.Mail.SmtpClient client = new System.Net.Mail.SmtpClient();
 client.EnableSsl = false;

// Create the message:
 var mail =
 new System.Net.Mail.MailMessage(sentFrom, message.Destination);

mail.Subject = message.Subject;
 mail.Body = message.Body;
 mail.IsBodyHtml = true;

// Send:
 return client.SendMailAsync(mail);

You have activated the password recovery

Posted on Leave a comment


The View / Shared folder contains all the visual controls that are to be displayed (used) in different parts of the site: are the old “user controls.” These controls can be called programmatically or called by the site itself automatically.

In this second case, imagine you create the “Student” model. In the View / Shared folder must exist (if not, create them) folders:

  • DisplayTemplates
  • EditorTemplates

If you enter in the 2 folders, 2 view dedicated to the display of “Student” model in two forms of viewing and editing, both named Studente.cshtml, the site will show you your custom control.

Posted on Leave a comment

ASP.NET MVC – First Controller

Visual Studio creates the Controller of Model. Let’s see how.

After creating the Model, Student.cs, in the project, in Visual Studio, position yourself on the Controllers directory. Push the right mouse button and press “Add” -> “Controller”. There appears a mask that offers you to choose the type of controller that you want to create. First on the list it is an empty controller, that is, a class that you have to write independently. The third should be a controller of type “Controller with View, using Entity Framework .” Visual Studio, starting with our Model, creates for us the Controller and view all of the CRUD operations. Choose this type.

Now appears a very important mask. From the top you are asked to choose:

  • Model Class. There is a drop-down menu that is automatically filled with all the classes in the Model (and all the classes in your project). Student choose.
  • Date Class context. You must choose the connection to the database that contains your table. The drop down menu shows all the classes in the project, derived from DbContext class,
  • Check “Generate Views” and “use a Page Layout“.
  • Controller name. Visual Studio there proposes a name one based on the Model you’ve selected. You can change the name, but let the word Controller at the end. (Eg. StudentsController)

Before having to set up the Controller, Visual Studio gives you everything you have written in the models and in DbContext is “right.” If the operation is successful now, in the Controllers directory you find the file StudentsController.cs.

Let’s examine this file. You are inside the class StudentsController derived from Controller.

public class StudentsController : Controller
 private ApplicationDbContext db = new ApplicationDbContext();

// GET: Students
 public ActionResult Index()
 return View(db.Students.ToList());

The class immediately initializes a connection to the database (db).

The first function we see is Index(). It ‘was created automatically and allow us to see the list of our students. Each function of this type is called “Action.” When, in our site we require a list of Students, we launch the Index function of the controller Students according to this path:

The Index function requires, from the connection to the database, all students (db.Students) and turns them into a list (db.Students.ToList ()). At this point sends our list of students to the view (return View (db.Students.ToList ());) As you can see, there isn’t the name of view but only a generic command “View”. The controller  searches in the list of views, for a view  called exactly like the function (Index) and … we see the students.

In the project, in the directory Views, you will find a folder Student with a list of automatically created files (we’ll analyze the view shortly). In the View directory will find the Shared directory. We can say that this directory contains all the “User Controls” ; all interface items that we intend to use in multiple pages; It contains all of the view that are used by other views. Even the one that in the past called “master page” is located here, in the form of “layout”. Look for the _Layout.cshtml file. This is the website of your graphics (we’ll analyze in detail, soon). Find  this piece of code:

<ul class="nav navbar-nav">
 <li>@Html.ActionLink("Home", "Index", "Home")</li>
 <li>@Html.ActionLink("About", "About", "Home")</li>
 <li>@Html.ActionLink("Contact", "Contact", "Home")</li>

These are the buttons you see above, when you launch your site. We need to see a new button to call the student page.

Add to this list html:

<li>@Html.ActionLink("My Student", "Index", "Students")</li>

Then we analyze the ActionLink component.

ActionLink (“Text Displayed”, “Name of Action,” Name of the Controller “). So we will have a button that when pushed will take us to page.

Try running the application and perform a login to test that everything is working.

Posted on Leave a comment

ASP.NET MVC. first Model – Code first

In this article we will create something new in our project. We will use the “Code First” approach, that is, “first” will write the code. It seems trite to say, but Visual Studio allows, for example, even the “Database First” approach.

Go into the Model directory and create a new class, for example Student.cs.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;

namespace MySite.Models
 public class Student

Add this namespace

using System.ComponentModel.DataAnnotations.Schema;

Our model / class is the representation, through its properties, a table that we will build into the database. First of all, let’s talk to the class as it is called to the table that we are preparing.

 public class Student

Then we create the properties – fields of the table. Add this namespace:

using System.ComponentModel.DataAnnotations;

our table consists of three fields

 public class Student
 public int ID { get; set; }

 [Display(Name = "Name")]
 public string NAME { get; set; }

 [Display(Name = "Surname")]
 public string SURNAME { get; set; }

The DataAnnotation, written on properties, defining the characteristics of the table fields: ID is the primary key (key), and SQLServer be responsible for assigning the number (DatabaseGeneratedOption.Identity). NAME is a required field (Required) of length 200, the description of which, during a display, it will be “Name” .etc.

Now we must add to DbContext the presence of this table. Open the ApplicationDbContext class and add, as a property, the new table:

public DbSet<Student> Students { get; set; }

Try running the application and perform a login to test that everything is working. Go to the database and built the table complying with his name and the names of the properties of the class.

Posted on Leave a comment



In the previous article we introduced the ApplicationDbContext class.

Search it in the project. You should find it within the IdentityModels.cs file. This class derives from the class that derives from IdentityDbContext DbContext.

DbContext is the connection class to a database. The class constructor has as a parameter the name of the connection string that we had previously found in the Web.config file.

public ApplicationDbContext() : base("DefaultConnection")

Let’s think about this information: in the Web.config you can put more connection strings, and then test the application on different databases, changing the parameter above, or you can create an application that connects to different databases by defining more than one DbContext.

Within a DbContext will be referenced all tables in the database we want to use in our application: or rather, all the tables that have constraints between them.

If for example we want to bind to the table of users created by Visual Studio, a second table created by us, the two tables should be part of the same DbContext. But we know nothing of the tables for the management of users created automatically. The class IdentityDbContext contains references to these tables. For this reason, our ApplicationDbContext not derived from DbContext but IdentityDBContext that contains, in fact, a little more information.

As you add tables for your application, you will work on ApplicationDbContext class. For a neater code, you go to create a new file in ApplicationDbContext.cs Models directory and copy, in this class, the ApplicationDbContext code (the only) which is IdentityModels.cs.

public class ApplicationDbContext : IdentityDbContext<ApplicationUser>
     public ApplicationDbContext()
     : base("DefaultConnection")

     public static ApplicationDbContext Create()
       return new ApplicationDbContext();

Try running the application and perform a login to test that everything is working.

Posted on Leave a comment mvc easy easy. Database

The default database

You have created your first project ASP.NET MVC. You can run it through Visual Studio. The site is fully functional and you can register a new user and log in. If you can register and access means “below” the site is already a database. To know where the database and which tables are present for user management, open in Visual Studio, SQL Server Object Explorer and you will see your database under

LocalDB – DefaultConnection

DefaultConnection is the name of the connection string used by your application to connect to the database. If you list the contents of Tables, you see the tables that manage users. If you have created the site using the Framework 4.5.1 or 4.5.2 these tables are 6.

Our SQL Server database

We do not want to work on the default database, but on a SQL Server database on our local machine or network. Create a SQL Server database somewhere. Now we need to connect our website to this database. Open the web.config file and look for the connectionStrings tag. Replace the connection string with a valid connection to your SQL Server database (you will find the connection strings on the Internet). Let the tag name to “DefaultConnection”. Launch the application through Visual Studio.

This is a new database then the user you created before the default database, does not exist here. You must re-register and, at this point, you need to log in. If you now check the contents of your SQL Server database (with Visual Studio SQL Server Object Explorer or with SQL Server Management Studio) you will see that we are also here 6 tables that allow the user management. Created by the site itself.

In your project, in fact, you can find the model tables that allow the user management (in the Models directory), and your site, seeing that the database did not exist any tables, has created them for you. Very comfortable.

From here on, you will create your models, that is, the containers of your data and the site will always attempt to create the tables related to you. This is not an easy process because it does not allow you errors or second thoughts as you create your model. It ‘better to say to the site not to stay from now on to check the consistency of the model – table: you will build your hand models and then your tables of SQL Server. To communicate this to the site, open the file Global.asax.cs, and in Application_Start () function, add this line:

Database.SetInitializer <YourSite.Models.ApplicationDbContext> (null);

Where ApplicationDbContext is the name of the class that connects to the database using the DefaultConnection string. Find this class in the project.