ASP.NET Weblogs

modern.ie

dotneteer — Fri, 17 May 2013 01:33:21 GMT

We are planning to update our very old web application so that it works better with modern web browsers. I have heard of modern.ie in the past and decided to give it a try. The site has a scanner that can scan a URL entered by a user. Unfortunately, our site requires log-in before getting to the page we want to scan. Fortunately, the site also offers a downloadable scanner that we can use in our local development environment.

I downloaded the scanner. It is packaged as a zip file. I unzipped the package and open the readme file. The tools requires node.js to work. Fortunately, it is fairly easy to setup the tool following the instructions. Firstly, download and install node.js; accept all defaults. The setup will add Node.js to the path. Although Node.js is known for hosting asynchronous web applications, it is actually just a javascript executing environment. Next, I open the command prompt, change to the directory that I unzipped the modern.ie tool and run “node lib/service.js”. A node hosted web server is listening on port 1337 so we just need to open a web browser and points to http://localhost:1337/. We can then enter the URL of a web page to scan. The scanner submits the data to modern.ie and a report is generated. The report is very good and it offers many suggestions and links that helps us to improve the page.

Red Gate Is Looking For Feedback On Its ASP.NET MVC Web Development Education Website

Paulo Morgado — Thu, 16 May 2013 22:43:00 GMT

Red Gate is looking for feedback on its ASP.NET Web Development Education website.

Visit their website and answer the survey.

World's largest startup competition and hackathon (AngelHack 2013) comes to Singapore in June 2013

Darren.Sim — Tue, 14 May 2013 15:59:00 GMT

Entrepreneurship has been on the rise in sunny Singapore over the past years with more and more youths having the guts to take the bold step to be different - stepping out of the comforts of a stable 9am to 5pm desk job to realize their dreams. Although I'm still fairly un-impressed with our startup scene here (in comparison with the US, or something closer to home - China and Korea), I am happy to say that things are going better and instead of complaining, many Singaporeans are taking the step to improve things at home after returning from the valley.

Photo Credits: sgentrepreneurs.com & darrensim.com

When talking about entrepreneurship in Singapore, we definitely cannot go without mentioning people like Wong Meng Meng and Sim Wong Hu who decided to call Singapore home despite their success overseas.

Photo Credits: http://www.todayonline.com/business/sme/gushing-ambition

Of course how can we not have a mention of GushCloud - one of Singapore's hottest startup properties? I first heard about GushCloud when I attended the Startup Asia Singapore conference last year; and their booth was so packed that I've to give it a miss to check out what they were up to. My real interaction with GushCloud only began while I was in a PR & Business development role that dealt with bloggers. Man, I must say that dealing with GushCloud was such a positive experience that I told Freda (from GushCloud) that if one day my blog ever has people reading it and it was good enough to be managed by a blogger management agency, I will queue overnight at their doors and beg for shelter under their wings. You would think that this is all some kind of cult; you bet I thought the same way too. But it was only when I met and chatted with GushCloud founders Vincent and Althea (thank you Sheena, without you, this would never have been possible) that I understand why. It's the drive and passion in them that generated this transfusion of positive forces that inspires and invigorates the entire company. I will not attempt to claim that I know them too well, but just a short chat with any of them and you will feel the vibes. Come June 2013, GushCloud will be hosting the world's largest Hackathon in Singapore at the Amazon HQ Singapore.

Photo Credits: outsideinmarketing.wordpress.com

Basically if you've not already heard about it, a hackathon is an event where like minded people come together to "hack together" something and make it work in a very short period of time. The objectives of such sessions is not to produce something that you can readily sell to people, but rather a working proof-of-concept of an idea, that allows others to visualize and actually test the idea using a working model.

Photo Credits: visual.ly

People who attends such sessions includes veterans as well as newbies, who attends hackathons mainly for learning, meeting new people and hoping to do their parts to change the world.

Read the entire post via http://www.darrensim.com/2013/05/14/worlds-largest-startup-competition-and-hackathon-angelhack-2013-comes-to-singapore-in-june-2013/

Consuming Windows Azure Mobile Services REST API from ASP.NET Web API App

shiju — Sun, 12 May 2013 09:59:18 GMT

Windows Azure Mobile Services lets the developers to use structured storage, user authentication and push notifications to Android, iOS, HTML, Windows Store, or Windows Phone 8 apps by leveraging the Windows Azure Cloud platform. Using with Windows Azure Mobile Services, you can enjoy the scalability power of Cloud to your Mobile apps. In this blog post, I will demonstrate how to persist data on Windows Azure Mobile Services Table from a ASP.NET Web API app by leveraging the Windows Azure Mobile Services REST API, and finally provides a generic type helper class for performing CRUD operations on the Windows Azure Mobile Services Table.

Consuming Windows Azure Mobile Services REST API from a ASP.NET Web API App

Windows Azure Mobile Services provides native API for Android, iOS, HTML, Windows Store, or Windows Phone 8 apps so that you can directly consume the Windows Azure Mobile Services from your native Mobile apps. In this post, we will be consume the Windows Azure Mobile Services from a ASP.NET Web API app. Windows Azure Mobile Services provides REST API so that we can easily consume it form our ASP.NET Web API app. This use case is based on a real world app I have recently worked, where iOS clients are consuming a REST API written in ASP.NET Web API and for some persistence over the REST API, we need to send push notifications to the iOS clients. So we are consuming the Windows Azure Mobile Services REST API from ASP.NET Web API app where we need to send push notifications. In this post, I am directly consuming the REST API from my app instead of using any REST API wrapper for .Net clients so that we can explore the Windows Azure Mobile Services REST API.

A Generic CRUD Helper Class for Windows Azure Mobile Services Table

Let’s create a generic type class for CRUD operations on the Windows Azure Mobile Services Table by consuming the REST API of Windows Azure Mobile Services. This generic type helper class can work with any type of Model object.

 public class MobileServiceRequestHelper<T> where T : class
    {
        private string tableEndpoint;
        private string applicationKey;
        private HttpClient client;
        public MobileServiceRequestHelper(string tableName)
        {
            tableEndpoint = ConfigurationManager
                .AppSettings["TableEndpoint"] + tableName ;
            applicationKey = ConfigurationManager
                .AppSettings["X-ZUMO-APPLICATION"];
            client = new HttpClient();
            client.DefaultRequestHeaders.
                Add("X-ZUMO-APPLICATION", applicationKey);
            client.DefaultRequestHeaders.Accept
                .Add(new MediaTypeWithQualityHeaderValue("application/json"));
        }
    }
 

We are taking the application key and Mobile Services URI from the web.config table and we will pass the Windows Azure Table name in the constructor method of our generic type helper class.

Insert Operation

The API documentation for Insert record operation available from here. The code block below provides the implementation of HTTP Post for inserting a new record onto Windows Azure Mobile Services Table. We are serializing the model object as JSON format and executing the HTTP request by calling the SendAsync method of HTTPClient class.

 public bool Post(T requestData)
{
    var obj = JsonConvert.SerializeObject(requestData,
        new JsonSerializerSettings()
        {
            NullValueHandling = NullValueHandling.Ignore
        });
    var request = new HttpRequestMessage(HttpMethod.Post,
        tableEndpoint);
    request.Content = new StringContent(obj, Encoding.UTF8,
        "application/json");
    var data = client.SendAsync(request).Result;
    if (data.IsSuccessStatusCode)
        return true;
    else
        throw new HttpResponseException(data.StatusCode);
}
 

Update Operation

The API documentation for Update record operation available from here. The code block below provides the implementation of HTTP Put for updating an existing record onto Windows Azure Mobile Services Table.

 public bool Put(T requestData, int id)
{
            
        var request = new HttpRequestMessage(new HttpMethod("PATCH"), 
            tableEndpoint + id);
        var obj = JsonConvert.SerializeObject(requestData);
        request.Content = new StringContent(obj, Encoding.UTF8, 
            "application/json");
        var data = client.SendAsync(request).Result;
        if (data.IsSuccessStatusCode)
            return true;
        else
            throw new HttpResponseException(data.StatusCode);     
}
 

Please note that Windows Azure Mobile Services used HTTP Verb “PATCH” for updating an existing record.

Delete Operation

The API documentation for Delete record operation available from here. The code block below provides the implementation of HTTP Delete for deleting an existing record from the Windows Azure Mobile Services Table.

 public void Delete(int id)
{
    var request = new HttpRequestMessage(HttpMethod.Delete, 
        tableEndpoint + id.ToString());
    var data = client.SendAsync(request).Result;
    if (!data.IsSuccessStatusCode)
        throw new HttpResponseException(data.StatusCode);
}
 

Query Operation

The API documentation for Query record operation available from here. The code block below provides the implementation of querying all records and filtering with id value from the Windows Azure Mobile Services Table.

 public IEnumerable<T> GetAll()
{
    var result = client.GetStringAsync(tableEndpoint).Result;
    var data = JsonConvert.DeserializeObject<IEnumerable<T>>(result);
    return data; 
}
public T Get(int id)
{
    var result = client.GetStringAsync(tableEndpoint +
        "?$filter=Id eq " + id).Result;
    var data = JsonConvert.DeserializeObject<IEnumerable<T>>(result);
    return data.FirstOrDefault();
} 
 

Windows Azure Mobile Services supports the Open Data Protocol (OData) so that you can query the data from Windows Azure Mobile Services Table by using the query option parameters provided by the OData.

The complete implementation of the MobileServiceRequestHelper class is available on Gist at https://gist.github.com/shijuvar/5562928

Consuming the REST API from ASP.NET Web API App

In the previous steps, we have created a generic type helper class for executing requests against Windows Azure Mobile Services REST API. The code block below provides the HTTP Post operation of our ASP.NET Web API where we inserting a new record onto Windows Azure Mobile Services table named “tokens”

 public HttpResponseMessage Post(Token token)
{
    if (ModelState.IsValid)
    {
        var req = new MobileServiceRequestHelper<Token>("tokens");
        var isSuccess = req.Post(token);
        if (isSuccess)
        {
            HttpResponseMessage response = Request.CreateResponse(
                HttpStatusCode.Created, token);
            return response;
        }
        throw new HttpResponseException(HttpStatusCode.BadRequest);
    }
    else
    {
        return Request.CreateErrorResponse(HttpStatusCode.BadRequest, ModelState);
    }
}
 

In the above code block, we are creating an object of MobileServiceRequestHelper with generic type Token and inserting a new record on Windows Azure Mobile Services table “tokens”.

Creating a simple Live Cricket Score using ASP.NET SignalR

imran_ku07 — Sat, 11 May 2013 14:00:00 GMT

Introduction:

I am from Pakistan. Like most of Pakistanis, I am also a huge fan of Cricket. Yesterday, I got some time from my busy job. I thought to create a simple Cricket Live Score feature using ASP.NET SignalR. It is also Interesting to note that the guys(David Fowler from West Indies and Damian Edwards from Australia) that are heavily involved in SignalR development are also cricket fans(correct me if I am wrong). In this article, I will show you how to create a simple 'Live Cricket Score' feature using SignalR. For a quick demo, just open this link in different browsers and in one browser just append ?admin= query-string(which will become the admin who update the score), then just click Update Score button many times until 2 overs finish(the match will be limited to 2 overs). For each click, the live score will be updated in each browser.

Description:

If you are new to SignalR then Getting Started will be great for you. Assuming that you have configured your application with ASP.NET SignalR. Let create a simple html page with following lines,

        
        <!DOCTYPE html>
        <html>
        <head>
            <title>Pakistan v/s India</title>
            <style>
                .team
                {
                    font-size: 15px;
                    padding-right: 10px;
                    font-weight: bold;
                    text-transform: capitalize;
                }
                .wickets,overs
                {
                    padding-right: 5px;
                }
            </style>
        </head>
        <body>
            <h1>Pakistan v/s India</h1>
            <div id="updateScore" style="display: none;">
                <input type="button" id="updateScoreLink" value="Update Score"/>
            </div>
            <br />
            <div data-bind="foreach: teams">
                <div>
                    <span class="team" data-bind="{ html: team }"></span>
                    <span class="runs" data-bind="{ html: runs }"></span>/<span class="wickets" data-bind="{ html: wickets }"></span>
                    <b>Overs</b> <span class="overs" data-bind="{ html: oversText }"></span>
                </div>
            </div>
            <script src="Scripts/jquery-1.8.2.min.js" ></script>
            <script src="Scripts/jquery.signalR-1.0.1.min.js"></script>
            <script src="signalr/hubs"></script>
            <script src="Scripts/knockout-2.2.0.js" ></script>
            <script type="text/javascript">
                // Here we start
            </script>
        </body>
        </html>

In the above page, we have referenced jquery, signalr and knockout scripts. We have also define a simple template which will show the runs, wickets and overs of both teams. For demo purpose, we have added a Update Score button in the page. This button when clicked will record a single ball of an over as well as runs scored in this ball . After each ball, I will tell SignalR to broadcast teams score-card across all the connected client. When the match finished(after 24 balls), I will again tell the SignalR to show the final result to all users. Here are the scripts which are required for our work,

  
        $(function () {
            var chat = $.connection.cricketHub,
                viewModel = {
                    teams: ko.observableArray([
                    { team: 'india', runs: 0, wickets: 0, balls: 0, oversText: '0.0' },
                    { team: 'pakistan', runs: 0, wickets: 0, balls: 0, oversText: '0.0'}])
                },
                index = 0;// index represant the position of the current batting team
            chat.client.updateScore = function (t) {
                viewModel.teams(JSON.parse(t));
            };
            chat.client.matchFinished = function (result) {
                alert(result);
            };
            $.connection.hub.start().done(function () {
                $('#updateScoreLink').click(function () {
                    var teams = viewModel.teams(),
                        team1 = teams[index],
                        team2 = teams[(index + 1) % 2],
                        wicketFalled = getRandomInt(0, 5) == 3 ? true : false;
                    // Assuming that the wicket will only fall when  a 0-5 random number is 3
                    team1.runs += getRandomInt(0, 6); // Get a random score between 0 to 6
                    team1.wickets += wicketFalled ? 1 : 0;
                    team1.balls += 1;
                    team1.oversText = truncate(team1.balls / 6).toString() + '.' + (team1.balls % 6).toString();
                    chat.server.updateScore(JSON.stringify(teams));
                    if (team1.balls === 12 && team2.balls === 12) {
                        $('#updateScoreLink').hide();
                        var message = (team1.runs > team2.runs ? team1.team : team2.team) + ' won';
                        message = team1.runs === team2.runs ? 'match tied' : message;
                        message += '\n' + team1.team + ': ' + team1.runs + '/' + team1.wickets + ' overs: ' + team1.oversText;
                        message += '\n' + team2.team + ': ' + team2.runs + '/' + team2.wickets + ' overs: ' + team2.oversText;
                        chat.server.matchFinished(message);
                    }
                    else if (team1.balls === 12) {
                        index = 1;// second team batting
                    }
                    viewModel.teams([team1,team2]);
                });
            });
            ko.applyBindings(viewModel);
            if (isAdmin()) {
                $('#updateScore').show();
            }
            
            function getRandomInt(min, max) {
                return Math.floor(Math.random() * (max - min + 1)) + min;
            }
            function truncate(n) {
                return Math[n > 0 ? "floor" : "ceil"](n);
            }
            function isAdmin(){
                // For demo, assuming that only admin can update the score 
                // and the admin will be user which have admin querystring.
                return location.href.indexOf('admin=') > -1
            }
        });

In the above scripts, we are initializing SignalR hub cricketHub object(we will see this hub class shortly), viewModel object which include team information(runs, wickets, etc) and index which represent the current batting team. Next, we have two client functions(updateScore and matchFinished) which will be invoked when the server broadcast a message to all clients.

When the hub start, we are registering event handler Update Score click event where we are getting a random run between 0-6, a wicket or not depending upon a random number, updating our view-model and then telling SignalR to broadcast the view-model across all the connected clients so that all clients automatically update their scorecard. Finally, when both teams completed their 12 balls, we will send the results to all the connected clients using SignalR. Note that for demo purpose we are only showing the Update Score button to the user which have admin= query-string.

Finally, here is our CricketHub class,

        
    public class CricketHub : Hub
    {
        public void UpdateScore(string teams)
        {
            Clients.All.UpdateScore(teams);
        }
        public void MatchFinished(string result)
        {
            Clients.All.MatchFinished(result);
        }
    }

Summary:

In this article, I showed you one of the usage of ASP.NET SignalR. You have seen that how easily we can create a real-time Live Cricket Score using the power of ASP.NET SignalR which works in every browser . Hopefully you will enjoy my this article too.

Entity Framework Code First Fluent Validation

Ricardo Peres — Thu, 09 May 2013 18:56:09 GMT

Back to Entity Framework Code First (EFCF) validation. On my previous post I mentioned that EFCF did not support fluent validation. While this is true, it isn’t too hard to implement one such mechanism, which is exactly why I am writing this!

I will be using the SavingChanges event to inject the validation logic, which will be implemented by strongly typed delegates. Let’s see some code:

        1: public static class DbContextExtensions

       2: {

       3:     private static IDictionary<Type, Tuple<Delegate, String>> entityValidations = new ConcurrentDictionary<Type, Tuple<Delegate, String>>();

       4:  

       5:     public static void AddEntityValidation<TEntity>(this DbContext context, Func<TEntity, Boolean> validation, String message) where TEntity : class

       6:     {

       7:         if (context == null)

       8:         {

       9:             throw new ArgumentNullException("context");

        }

  

        if (validation == null)

        {

            throw new ArgumentNullException("validation");

        }

  

        if (String.IsNullOrWhiteSpace(message) == true)

        {

            throw new ArgumentNullException("message");

        }

  

        if (entityValidations.ContainsKey(typeof(TEntity)) == false)

        {

            (context as IObjectContextAdapter).ObjectContext.SavingChanges += delegate

            {

                if (context.Configuration.ValidateOnSaveEnabled == true)

                {

                    IEnumerable<TEntity> entities = context.ChangeTracker.Entries<TEntity>().Where(x => x.State == EntityState.Added || x.State == EntityState.Modified).Select(x => x.Entity).ToList();

  

                    foreach (TEntity entity in entities)

                    {

                        String error = ValidateEntity(entity);

  

                        if (String.IsNullOrWhiteSpace(error) == false)

                        {

                            throw (new ValidationException(error));

                        }

                    }

                }

            };

        }

  

        entityValidations[typeof(TEntity)] = new Tuple<Delegate, String>(validation, message);

    }

  

    private static String ValidateEntity<TEntity>(TEntity entity)

    {

        Type entityType = typeof(TEntity);

  

        if (entityValidations.ContainsKey(entityType) == true)

        {

            Tuple<Delegate, String> entry = entityValidations[entityType];

            Func<TEntity, Boolean> validation = entry.Item1 as Func<TEntity, Boolean>;

  

            if (validation(entity) == false)

            {

                return (entry.Item2);

            }

        }

  

        return (null);

    }

}

We have an extension method that allows declaring, for an entity type, a validation expression, such as this:

       1: ctx.AddEntityValidation<SomeEntity>(x => x.SomeProperty != null, "SomeProperty is required");

The validation will be fired when the SaveChanges method is called and the errors will be encapsulated in a ValidationException:

       1: try

       2: {

       3:     ctx.SaveChanges();

       4: }

       5: catch (ValidationException ex)

       6: {

       7:     //see content of ex.ValidationResult.ErrorMessage

       8: }

This code can certainly be improved – multiple validations per entity, property-based validations, etc – but I think it is good enough to illustrate my technique.

One final note: the fluent validation will only be fired if the ValidateOnSaveEnabled property is set to true, which is the default.

Entity Framework Code First Validation

Ricardo Peres — Thu, 09 May 2013 11:40:54 GMT

Introduction

Most persistence frameworks implement some kind of custom validation of entities before they are sent to the database. By custom I mean something more than just “is not null”, “has XX characters”, etc. This typically includes individual properties as well as validation of the entity as a whole – for example, checking that a property’s value is valid when used together with another property’s value.

Entity Framework Code First is no exception. Out of the box it already offers a number of possibilities for validating entities that cover typical scenarios: validation by attributes or by a validation method. One validation left out is one based on XML, but since Code First doesn’t really use XML, it should be no surprise, and the other is fluent validation, something that really should be supported.

Let’s explore each of these possibilities.

Overriding ValidateEntity

The DbContext class has a virtual method called ShouldValidateEntity that is called for each entity about to be persisted – meaning, inserted or updated –, and, when it returns true – which it does by default – will trigger a call to ValidateEntity, another virtual method. In this method, we have a chance to validate our entities any way we like. An example might be, for instance, checking if the entity to be saved implements IDataErrorInfo and extract validation information from this implementation:

        1: protected override DbEntityValidationResult ValidateEntity(DbEntityEntry entityEntry, IDictionary<Object, Object> items)

       2: {

       3:     DbEntityValidationResult result = base.ValidateEntity(entityEntry, items);

       4:     IDataErrorInfo dei = entityEntry.Entity as IDataErrorInfo;

       5:     

       6:     foreach (String propertyName in entityEntry.CurrentValues.PropertyNames)

       7:     {

       8:         String errorMessage = dei[propertyName];

       9:  

      10:         if (String.IsNullOrWhiteSpace(errorMessage) == false)

      11:         {

      12:             result.ValidationErrors.Add(new DbValidationError(propertyName, errorMessage));

      13:         }

      14:     }

      15:  

      16:     return (result);

      17: }

For the validation to occur, the ValidateOnSave property must be true, which it is by default.
Don’t forget to always call the base implementation!

Applying Validation Attributes

Another option, which also applies to ASP.NET MVC validation (see http://weblogs.asp.net/ricardoperes/archive/2012/06/03/asp-net-mvc-validation-complete.aspx) is using validation attributes, that is, attributes that inherit from ValidationAttribute. The base ValidateEntity method of DbContext also checks for these attributes, another reason why you should always call it. Let’s see an example:

       1: [Serializable]

       2: [AttributeUsage(AttributeTargets.Property, AllowMultiple = false, Inherited = true)]

       3: public sealed class PositiveAttribute : ValidationAttribute

       4: {

       5:     protected override ValidationResult IsValid(Object value, ValidationContext validationContext)

       6:     {

       7:         Int64 longValue = Convert.ToInt64(value);

       8:  

       9:         if (longValue <= 0)

      10:         {

      11:             return (new ValidationResult("Value cannot be negative or zero"));

      12:         }

      13:  

      14:         return (ValidationResult.Success);

      15:     }

      16: }

You would then apply this to some property in your entity:

       1: public class MyEntity

       2: {

       3:     [Positive]

       4:     public Int64 MyAlwaysPositiveNumber { get; set; }

       5: }

The “problem” with this approach is that you must include any assemblies containing these custom validation attributes together with your model. If they are on the same assembly, there’s no problem.

By the way, you can specify multiple validation attributes and you can even apply them to the whole class, not just a property.

Implementing IValidatableObject

Another option, also common to MVC, is having your entities implement IValidatableObject. This interface defines a contract for returning a collection of validation errors for an entity. Here’s a sample implementation:

       1: public class Contract : IValidatableObject

       2: {

       3:     public String Name { get; set; }

       4:     public DateTime StartDate { get; set; }

       5:     public DateTime EndDate { get; set; }

       6:  

       7:     public IEnumerable<ValidationResult> Validate(ValidationContext validationContext)

       8:     {

       9:         if (this.StartDate >= this.EndDate)

      10:         {

      11:             yield return (new ValidationResult("The end date is before or the same as the start date", new String[] { "StartDate", "EndDate" }));

      12:         }

      13:     }

      14: }

Handling SavingChanges Event

The “underlying” ObjectContext – which, in fact, is only created if requested – exposes a SavingChanges event which is triggered whenever Entity Framework is about to send changes to the database, typically whenever the SaveChanges method is called. If we handle this event, we can perform our custom validation before our entities are saved, and in case something is wrong we can throw an exception to cancel the saving process:

       1: (ctx as IObjectContextAdapter).ObjectContext.SavingChanges += ObjectContext_SavingChanges;

       2:  

       3: void ObjectContext_SavingChanges(Object sender, EventArgs e)

       4: {

       5:     ObjectContext octx = sender as ObjectContext;

       6:     IEnumerable<Object> entities = octx.ObjectStateManager.GetObjectStateEntries(EntityState.Added | EntityState.Modified).Select(x => x.Entity);

       7:  

       8:     //do custom validation and throw an exception if something wrong is found

       9:  

      10: }

This has the arguable advantage that it decouples the validation process from the entities and the context themselves.

Conclusion

In case you are using any of these validation techniques, always surround calls to SaveChanges inside a try…catch block and look out for a DbEntityValidationException or your own exception, if you followed the SavingChanges approach. Inside DbEntityValidationException you have an EntityValidationErrors that contains all the details:

       1: try

       2: {

       3:     ctx.SaveChanges();

       4: }

       5: catch (DbEntityValidationException ex)

       6: {

       7:     foreach (DbEntityValidationResult result in ex.EntityValidationErrors)

       8:     {

       9:         //..

      10:     }

      11: }

Alternatively, you can explicitly call GetValidationErrors and see the collection of errors from all sources, except, of course, SavingChanges, because the context is not actually in the process of saving changes, for all entities currently being tracked by the context.

The order by which these validation processes are applied is:

ValidateEntity
ValidationAttribute (from base ValidateEntity)
IValidatableObject (from base ValidateEntity
SavingChanges (only if no errors are found)

Pick the one that better suits your needs!

Blogs Portugueses Sobre SharePoint

Ricardo Peres — Thu, 09 May 2013 10:26:00 GMT

This post is in portuguese only, sorry!

A partir de um comentário no LinkedIn, no grupo da Comunidade Portuguesa de SharePoint (http://www.linkedin.com/groups?home=&gid=996587&trk=anet_ug_hm) foi começada uma lista dos blogs de autores portugueses e brasileiros sobre SharePoint, ainda que não exclusivamente. Vou publicar essa lista aqui, e tentarei mantê-la actualizada.

Comunidade Portuguesa de SharePoint - http://www.sharepointpt.org/
Tech Talk PT - http://techtalkpt.wordpress.com/
My time break for SharePoint - http://aaclage.blogspot.pt/
Stepping stones for crossing technological ponds - http://mystepstones.wordpress.com/
Raquel Aline kb - http://raquelalineblog.wordpress.com/
EPM+ - http://blogs.technet.com/b/epmmais/
Demétrio Silva – Sql Server - http://demetriosilva.wordpress.com/
Ricardo Calejo - http://ricardocalejo.livethoughts.net/
Development With A Dot - http://weblogs.asp.net/ricardoperes/
ponto de partilha - http://pontodepartilha.blogspot.pt/
ShareMídia - http://crimac.net/sharemidia/
ftduarte.blogspot.com - http://ftduarte.blogspot.pt/
André Vala - http://blogit.create.pt/blogs/andrevala/
Miguel Isidoro - http://blogit.create.pt/blogs/miguelisidoro/

Se conhecerem mais, por favor, comuniquem-mos!

System.InvalidOperationException: jsdebug Web Service method name is not valid

jhallal — Tue, 07 May 2013 20:08:00 GMT

If you are getting a 'web service undefined' error when calling a web service from Javascript which is defined inside the ScriptManager tag like so:

<asp:ScriptManager ID="ScriptManager1" runat="server">
<Services>
<asp:ServiceReference Path="~/Services/WebService.asmx" InlineScript="True" />
</Services>
</asp:ScriptManager>

Actual Error:

System.InvalidOperationException: jsdebug Web Service method name is not valid.

at System.Web.Services.Protocols.HttpServerProtocol.Initialize()

at System.Web.Services.Protocols.ServerProtocolFactory.Create(Type type, HttpContext context

Solution:

To resolve this issue, run the following command line:

C:\Windows\Microsoft.NET\Framework64\v4.0.30319>aspnet_regiis -i

Using the Enterprise Library 6 Configuration Console with Visual Studio 2012

Ricardo Peres — Tue, 07 May 2013 16:36:06 GMT

You will have to download and run the Configuration Console from http://www.microsoft.com/en-us/download/details.aspx?id=38789, there is no NuGet package for it. After that, you will get a context menu for each project on the solution for editing the configuration: