Eran Sakal - Blog

VS2010 debugging problems - "The breakpoint will not currently be hit..."

Eran Sakal — Fri, 11 Nov 2011 22:30:00 GMT

This article applies to the following technologies: Silverlight, C#, Visual Studio 2010 (vs2010)

There are times when Visual Studio decides that you have too much spare time and starts acting weird by ignoring your breakpoints while debugging. This behavior has multiple symptoms:

Your breakpoints are shown as empty red circles instead of the regular full circles
When hovering with the mouse on the breakpoint you receive the annoying message: "The breakpoint will not currently be hit..."
And most importantly, Visual Studio ignores your breakpoints

The following steps should hopefully solve your problem. You can try them in any order that you prefer.

step 1 - Delete temporary asp.net files from your machine.

You can find the temporary directory at "C:\windows\Microsoft.NET\Framework\v4.0.30319\Temporary ASP.NET Files". Notice that the framework version (bolded text) represents the framework which is used by your server and can vary between machines. To determine the version which is currently in use, click on the Development Server icon on the system tray and take note of the ASP.NET Version field, as seen in the following screenshot:

step 2 – Clear your browser cache, then re-open the browser.

step 3 – (most elusive) - Verify that you are not running vs2010 in compatibility mode.

Right click on the Visual Studio icon –> properties –> compatibility –> un-check the option 'Run this program in compatibility mode for', as seen in the following screenshot:

step 4 – Remove the 'bin' and 'obj' directories from all your projects in the solution.

These folders are created by each project while compiling. They are not shown in the Visual Studio environment so in order to delete them you should use your system's search dialog.

step 5 - Delete the 'suo' file of the solution.

This is a hidden file located in the same place and named the same as your solution file.

step 6 – Make sure you are executing vs2010 on 'Debug' configuration mode and not 'Release' mode.

step 7 – Reset vs2010 using the "Import and Export Settings Wizard"

These settings affect the way Visual Studio behaves according to your programming language (C++, C#, F#). They also affect the debugger feature. To reset vs2010 settings you may read the following article.

step 8 – Make sure that the web project is set to be the startup project.

step 9 – Access the web project properties –> Web –> Verify that both 'ASP.NET' and 'Silverlight' are marked.

If all of this doesn't work you may try the following article which contains additional suggestions for solving this issue.

Re-using WCF service among several Silverlight applications

Eran Sakal — Wed, 05 Oct 2011 22:15:00 GMT

This article is about creating WCF RIA service in class library assembly instead of in the Silverlight application. For unknown reason (at least for me) most, if not all of the Silverlight samples implement the service logic in the main Silverlight application project. But since MVVM is all about de-coupling and re-using, Those services should be implemented in class library and exposed by the application.

Press here to download demo solution. In this solution you will find a working service as shown above.

Creating the service in class library project

1 Open your application solution.

2 Add project of type 'Class Library' (Notice not to select 'Silverlight class library').

3 In the newly created project add an item of type 'WCF service'. This file extension is '.cs' and not '.svc'. Don't worry about it at the moment.

Visual studio creates a regular WCF service with service contract (interface), service concrete class and relevant attributes.

4 Add one or more methods to the service.

Exposing the service from the Silverlight application

The following steps should be executed in the Silverlight web project. We are going to create a service which will operate as proxy to the service we created in previous steps.

5 Add a project reference to the WCF service project from the Silverlight web project.

6 Add an item of type 'Silverlight-enabled WCF service'

7 Check if a service endpoint was added to 'system.serviceModel' element in the 'web.config' file. If so, delete the configuration for that service.

Visual studio created regular empty service. Our goal is to use this service as proxy to the service that you created earlier. In the following steps you will convert the service to a proxy using inheritance.

8 Open the file with the extension 'svc.cs' of the newly created service.

9 Remove the class' content as well as the attribute 'ServiceContract'.

10 Inherit from the service class you created in the separate project.

If you have reached this step then you finished creating a service in a class library. You may now create a service reference to the service proxy and use it as all the regular services.

Note, If you followed the instructions carefully you probably noticed that you didn't need to add any configuration to the configuration file 'web.config'. The reason is that Silverlight runtime engine creates dynamic configuration on the fly when a client tries to use the service.

Recap

In this article I demonstrated how you can easily create services in class library assembly. Doing so allow you to re-use the service between applications.

Demo

Press here to download demo solution. In this solution you will find a working service as shown above.

Silverlight - How to support uploading files larger than 16K in WCF RIA services

Eran Sakal — Mon, 03 Oct 2011 16:35:00 GMT

This article applies to the following technologies: Silverlight, WCF RIA, Azure

press here to view live example

Intro

I have written this article after spending some time configuring WCF RIA service in my application. I wanted to create a service which will allow uploading files larger than 16KB. The problem was that Silverlight doesn't handle exceptions in WCF very well, which makes it hard to troubleshoot. In this article I will cover three major exceptions that I had encountered during the implementation.

In this article I plan to cover the following topics.

Section 1 - Revealing the actual exception behind 'HTTP/1.1 500 Internal Server Error' / 'The remote server returned an error: NotFound'.
Section 2 - Solving the annoying exception 'The maximum array length quota (16384) has been exceeded while reading XML data...'.
Section 3 - Overcoming the exception 'HTTP/1.1 415 Unsupported Media Type' while calling a WCF Silverlight service.

Download Sample

Press here to download demo solution. In this solution you will find a working service as shown above.

Section 1 - Revealing the actual exception behind 'The remote server returned an error: NotFound'

Silverlight fails to report on WCF exceptions correctly. Most of the exceptions being thrown, end up as a with general exception which conceal the actual problem. Some exceptions can be seen using Fiddler on the client side. A better and more profound way should be logging the details of the actual exception on the server side.

In this section I will show you how to enable WCF logging on the server. I will use some tools that can be found in VS2010.

s1.1 Open the requested project in VS2010.

s1.2 In the upper menu select 'Tools –> WCF service configuration tools'. The tool will be opened.

s1.3 Open the file 'web.config' located in the web project ('File –> Open –> Config file').

s1.4 In the left panel named 'Configuration' expand the node 'Diagnosis'.

s1.5 Enable WCF 'Tracing' as shown in the following image.

s1.6 Remember the path of the log file that will be used to store the log entries. In the example above the file path is 'c:\web_tracelog.svclog'. You can leave the default path as is.

s1.7 Save your changes in the tool and return to vs2010. The 'web.config' file should be updated.

s1.8 Run your application and reproduce the exception.

In order to read the log file you will use another tool which has already been installed on your machine as part of the VS2010 installation and is called 'Service Trace Viewer Tool'.

s1.9 Use the Windows explorer to open the log file. The tool is mapped as default for files with extension ‘.svclog’ thus the tool should be opened automatically.

This tool is used to read the log easily. In the ‘Activity’ table each row represents a WCF activity in the server. Rows marked in red indicate that the activity reported an exception. Select the last row marked in red. In the right panel select the message which is also marked in red…

The actual exception should be shown in the tool. Don’t forget to remove the log from the ‘web.config’ file before going to production (Removing can be done by the tool by setting 'Tracing' to off).

Section 2 - Solving the annoying exception “The maximum array length quota (16384) has been exceeded while reading XML data”

This exception is raised when trying to send messages in a wcf service larger which are larger than 16KB. In regular WCF usage you are registering the services in the 'web.config'. When using Silverlight WCF RIA you don't register the services because the Silverlight framework performs it for you during run-time using the default configuration. If you want to customize one of the services (i.e a service which retrieves a file or some other huge chunk of data) you should perform the following steps:

s2.1 Open file 'ServiceReferences.ClientConfig' in the Silverlight application project. This file contains all the services which are used in the Silverlight application.

s2.2 Create a custom binding as shown in the attached code sample. Modify the sample according to your service information such as service address, contract and binding/endpoint names. The important part in this step is that in lines 3-8 you create a custom binding with the attributes 'maxReceivedMessageSize' and 'maxBufferSize' set to their maximum value. In line 12 you configure the service to use the new custom binding.

<system.serviceModel>
    <bindings>
        <customBinding>
            <binding name="CustomBinding_ILargeBufferService">
                <binaryMessageEncoding />
                <httpTransport maxReceivedMessageSize="2147483647" maxBufferSize="2147483647" />
            </binding>
        </customBinding>
    </bindings>
    <client>
      <endpoint address="../Services/LargeBufferService.svc" contract="LargeBufferService.ILargeBufferService"
          binding="customBinding" bindingConfiguration="CustomBinding_ILargeBufferService"
            name="CustomBinding_ILargeBufferService" />
    </client>
</system.serviceModel>

s2.3 Open file 'web.config' in the Silverlight web project.

s2.4 Modify node 'system.serviceModel' to include the following code sample.

<system.serviceModel>
    <behaviors>
        <serviceBehaviors>
            <behavior name="">
                <serviceMetadata httpGetEnabled="true" />
                <serviceDebug includeExceptionDetailInFaults="false" />
            </behavior>
        </serviceBehaviors>
    </behaviors>
    <bindings>
        <customBinding>
            <binding name="LargeBufferServiceCustomBinding">
                <binaryMessageEncoding>
                    <readerQuotas maxArrayLength="2147483647" />
                </binaryMessageEncoding>
                <httpTransport maxReceivedMessageSize="2147483647" maxBufferSize="2147483647" />
            </binding>
        </customBinding>
    </bindings>
    <serviceHostingEnvironment aspNetCompatibilityEnabled="true"
        multipleSiteBindingsEnabled="true" />
    <services>       
      <service name="WCFLargeBuffer.Web.Services.LargeBufferService">
          <endpoint address="" binding="customBinding" bindingConfiguration="LargeBufferServiceCustomBinding"
              contract="WCFLargeBuffer.Web.Services.ILargeBufferService" />
        <endpoint address="mex" binding="mexHttpBinding" contract="IMetadataExchange" />
      </service>
    </services>
</system.serviceModel>

Where:

Lines 3-8 – This is the default behavior and most probably already exists in your file.
Lines 11-18 – Define a custom binding whose definitions match those we defined in the Silverlight application project.
Lines 23-27 – Define the service which should support the large message size. Notice that the 'address' attribute is empty. The connection to the service is done by mapping the attributes 'name' and 'contract' to the concrete implementation of the service and its interface (contract). In line 24 you configure the service to use the binding which was defined in lines 11-18.

Section 3 - Overcoming the exception 'HTTP/1.1 415 Unsupported Media Type' when calling a WCF Silverlight service

This exception is a bit tricky since the exception doesn't indicate the source of the problem. It usually means there's a problem with the way the service is configured. If you followed section 2 you should not encounter that problem. The solution of this exception in Silverlight WCF RIA applications is quite simple.

When configuring the service in the 'web.config' file we set the attribute 'address' to be the empty string. This causes Silverlight difficulties in finding the concrete service implementation. This is where conventions come into consideration. You must ensure that the 'name' attribute of the service contains the full namespace of the service concrete implementation (class). I formatted the relevant attribute in bold in the provided sample code (line 1).

<service name="WCFLargeBuffer.Web.Services.LargeBufferService">
    <endpoint address="" binding="customBinding" bindingConfiguration="LargeBufferServiceCustomBinding"
        contract="WCFLargeBuffer.Web.Services.ILargeBufferService" />
  <endpoint address="mex" binding="mexHttpBinding" contract="IMetadataExchange" />
</service>

Article Recap

In this article I covered 3 known exceptions which many developers dealt with while developing Silverlight WCF RIA services. In addition this article introduced a way to log WCF for troubleshooting handling in section 1.

press here to view live example

Appendix A

This is the full listing of the exception handled in section 2:

“There was an error deserializing the object of type WCFLargeBuffer.Web.Services.DoWorkArgs. The maximum array length quota (16384) has been exceeded while reading XML data. This quota may be increased by changing the MaxArrayLength property on the XmlDictionaryReaderQuotas object used when creating the XML reader. Line 1, position 38134.'. Please see InnerException for more details.”

Silverlight PRISM + MVVM - Displaying a dialog to the user - Part 1

Eran Sakal — Fri, 30 Sep 2011 01:45:00 GMT

This article applies to the following technologies: C#, PRISM 4, Silverlight 4

Press here to view live example

Intro

Programmers who don’t use MVVM have easy and affective ways to display a dialog to the user (Message box dialog, confirmation dialog, custom dialog). But what’s the best way to display a dialog with MVVM? In other words: How can one trigger a dialog from the view-model without apathetic to the UI?

This is how not to do it:

MessageBox.Show("This is the message", "This is the title",MessageBoxButton.OK);

The problem with the above code is that the regular MessageBox c# type determines the UI visual and cannot be modified by the view. It will always show a blocking popup. The developer cannot customize the view of the dialog, make it asynced or simulate it for unit tests scenarios. To code it right you need to de-couple the visual of the dialog from the business logic using the MVVM pattern guidelinces.

For the sake of simplicity I didn’t trigger any calls to ‘PropertyChanged’ event in code samples shown in the article. Please refer to the demo for obtaining the full code.

Demo

You can download the demo used in this article from the following link.

Article structure

This article is about the following issues:

Section 1 – Displaying a message box to the user.
Section 2 - Displaying a confirmation dialog to the user.
Section 3 (Part 2) - Changing the visibility of the default message box / confirmation dialog.
Section 4 (Part 2) - Displaying a custom dialog (using Child window).

Article goals

Use the PRISM framework to show dialogs and interact with the user.
De-couple the visual from the logic using MVVM pattern.
Avoid using JavaScript objects like ‘Messagebox’ or ‘Confirmation’.
Avoid using 3rd party tools (except for PRISM which is free).

Prerequisites

Before displaying any dialog you must perform the following.

p.1 If you haven’t done this already, download PRISM 4 from the following link.

p.2 Add the following references to the Silverlight project in which you are going to implement the dialog.

System.Windows.Interactivity.dll (part of .net framework)
Microsoft.Expression.Interactions.dll (part of .net framework)
Microsoft.Practices.Prism (part of Prism 4)
Microsoft.Practices.Prism.Interactivity (part of Prism 4)

Section 1 – Displaying a message box dialog

The following section will demonstrate how to show simple message box dialog to the user.

Modifying the view-model

In order to display the dialog you will use the type ‘InteractionRequest<Notification>’. This type will be used as proxy between the view-model to the view and will include information about the dialog like title and message.

Coding conventions

s1.1 To adhere to the coding convention ensure that your class name uses the following pattern ‘{View model name}ViewModel’, for example – ‘UsersViewModel’.

Exposing property which represent the dialog

s1.2 Expose a property of type ‘InteractionRequest<Notification>’. Later you will bind the UI popup dialog to this property. Use the following code sample:

public InteractionRequest<Notification> ShowMessagebox { get; set; }

where:

As mentioned at the beginning of the article – to keep things simple, I didn’t trigger ‘PropertyChanged’ event in the code sample.

s1.3 In the view-model constructor, initialize the property with a concrete instance. Use the following code sample:

ShowMessagebox = new InteractionRequest<Notification>();

Displaying the dialog when needed

s1.4 Finally, use the following code sample to trigger the display of the dialog to the user:

ShowMessagebox.Raise(new Notification { Content = "This messagebox was triggered from the ViewModel", Title = "Nice Title" }, arg =>
{
    // Optional - do something after the user accecpt the messagebox
});

Where:

The 1st argument (‘Notification’) contains the information that will be displayed to the user.
- In this example I used a string as the ‘content’. But the content could actually be anything that may eventually be rendered using a data template.
The 2nd argument (‘Callback’) is optional. Use this callback to execute post handle user interaction after the user closes the dialog.
The ‘Notification’ instance that you pass as the first argument will be used as the datacontext of the UI popup.

You just finished modifying the view-model but you still need to modify the view before you can test the code.

Modifying the view

In this part you are going to add the visual part of the dialog by binding to the property you added to the view-model.

Coding conventions

s1.5 To adhere to the coding convention ensure that your class name uses the following pattern ‘{View name}View’, for example – ‘UsersView’.

Add required namespaces

s1.6 Add the following namespaces to the xaml:

xmlns:ei="http://schemas.microsoft.com/expression/2010/interactivity"    
xmlns:prism="http://www.codeplex.com/prism"

Add InteractionRequestTrigger behavior

s1.7 The ‘InteractionRequestTrigger’ is used to bind between the view-model exposed property and the visual element in the view.

Use the following code sample, append it as first child of the grid element ‘LayoutRoot’:

<ei:Interaction.Triggers>
    <prism:InteractionRequestTrigger SourceObject="{Binding ShowMessagebox}">
        <prism:PopupChildWindowAction/>
    </prism:InteractionRequestTrigger>
</ei:Interaction.Triggers>

Where:

Line 2 – The property ‘SourceObject’ is bound to the property that you exposed in the view-model. In this case ‘ShowMessagebox’ property.
Lines 3-5 – Define the visual element which is part of prism framework.
Notice – If your xaml already contains ‘Interacation.Triggers’ attached property (line 1) then you should avoid adding another one. Append lines 3-5 to the exists property.

You just finished implementing a message box dialog using PRISM guidelines and MVVM principles.

Section 2 – Displaying a confirmation dialog

Displaying a confirmation dialog is very similar to the implementation of displaying a messagebox. In this section I will focus on the differences so you should read section 1 before continuing.

Modifying the view-model

Exposing a property which represents the dialog

s2.1 Expose a property of type ‘InteractionRequest<Confirmation>’. Notice that the generic type is ‘Confirmation” and not ‘Notification’. Use the following code sample:

public InteractionRequest<Confirmation> ShowConfirmation { get; set; }

s2.2 In the constructor, initialize the property with a concrete instance. Use the following code sample:

ShowConfirmation = new InteractionRequest<Confirmation>();

Displaying the dialog when needed

s2.3 Use the following code sample to trigger the display of the dialog to the user:

ShowConfirmation.Raise(new Confirmation { Content = "This confirmation dialog was triggered from the ViewModel. Do you accept?", Title = "Confirmation Title" }, confirmation =>
{
    if (confirmation.Confirmed)
    {
        // User accepted the request (pressed on 'ok' button)
    }
    else
    {
        // User rejected the request (pressed on 'cancel' button)
    }
});

Modifying the view

This part is almost identical to the matching part in section 1. The only difference is the property name the ‘SourceObject’ is bound to.

Add required namespaces

s2.4 Add the following namespaces to the xaml:

xmlns:ei="http://schemas.microsoft.com/expression/2010/interactivity"    
xmlns:prism="http://www.codeplex.com/prism"

Add InteractionRequestTrigger behavior

s2.5 Use the following code sample, add it as first child of the grid element ‘LayoutRoot’:

<ei:Interaction.Triggers>
    <prism:InteractionRequestTrigger SourceObject="{Binding ShowConfirmation}">
        <prism:PopupChildWindowAction/>
    </prism:InteractionRequestTrigger>
</ei:Interaction.Triggers>

Article recap

In this article I demonstrated how to show common dialogs such as messagebox and confirmation. In next article I will focus on more advanced usage such as displaying custom dialogs and style modification. You can download project located at the beginning of the article.

Press here to view live example

Silverlight - How to clone any instance of object (including EF entities)

Eran Sakal — Thu, 01 Sep 2011 22:30:00 GMT

מאמר זה רלוונטי לטכנולוגיות הבאות: C#, EntityFramework, Silverlight 4

הקדמה

מאמר זה מציג דרכים לשכפול של אובייקטים בSilverilght. פעולה כזו נדרשת לא מעט כאשר מתעסקים עם נתונים ורוצים לאפשר למשתמש דרך לשכפל אותם.

ראיתי מספר דוגמאות ברשת שבהן מבצעים שכפול ידני (יצירת אובייקט והעתקת כל property בנפרד). הדרכים שמופיעות במאמר זה מראות כיצד ניתן לעשות פעולה זו באופן אוטומטי ובכך לצמצם טעויות אנוש, ליצור קוד נקי וקריא יותר, למנוע קידוד פרטני hardcoded ומימוש פתרון גנרי.

מגבלות טכנולוגיות

הדרכים המתוארות במאמר משתמשות בReflection. מטעמי אבטחה חסמו בSilverlight את האפשרות לגשת לPrivate members. המשמעות היא שהאובייקט המשוכפל יהיה זהה לאובייקט המקור בproperties שהם public בלבד. קישור להסבר על הגבלה זו בMSDN.

שיטה 1 – שכפול באמצעות DataContractSerializer

בשיטה זו אנחנו עושים שימוש באובייקט DataContractSerializer כדי ליצור את השכפול.

הכנה

הוסף רפרנס לקובץ הבא:

System.Runtime.Serialization.dll

הוסף את הusing הבא בתחילת הקובץ:

using System.Runtime.Serialization;

קידוד

נגדיר אובייקט מסוג Person. בהמשך המאמר נשתמש באובייקט זה לצורך הדגמה של השיטות.

public class Person
{
    public string Name { get; set; }
    public int ChildrenCount { get; set; }        
    public DateTime Birthday { get; set; }

    [IgnoreDataMember]
    public string Comments { get; set; }
}

השתמש בקוד הבא כדי לשכפל את האובייקט.

public T CloneItem<T>(T originalItem) where T:class
{
    T result;
    
    using (var stream = new System.IO.MemoryStream())
    {
        var serializer = new System.Runtime.Serialization.DataContractSerializer(typeof(T));

        // serialize the instance into memory.
        serializer.WriteObject(stream, originalItem);
        stream.Seek(0, System.IO.SeekOrigin.Begin);

        // de-serializing from memory will create new instance 
        result = (T)serializer.ReadObject(stream);                
    }

    return result;
}

כאשר:

השורות הרלוונטיות שמבצעות את העתקה הינן שורות 5-15.
שורות 10-11 מיצרות העתק של האובייקט בזיכרון (serialization).
שורה 14 – מייצרת אובייקט חדש באמצעות de-serialization של האובייקט שנשמר בזיכרון בשורות 10-11.

נקרא למתודה CloneItem כדי לשכפל אובייקט מסוג Person

Person originalPerson = new Person { Name = "Eran", Birthday = new DateTime(1980, 8, 11), Comments = "This will not be copied" };
Person clonedPerson = CloneItem(originalPerson);

הערות

שימוש בשיטה זו אפשרי רק החל מ – wcf .net 3.5 SP1.
שיטה זו מאפשרת העתקה של אובייקטים שיש להם parameterless constructor (ידוע גם כ-default constructor). בלי זה לא יתבצע השכפול.
שיטה זו מאפשרת גמישות רבה. בזכות השימוש ב-DataContractSerializer ניתן להשפיע על השכפול בעזרת attributes. בשורה 7 במחלקה Person השתמשתי בIgnoreDataMember attribute כדי למנוע העתקה של המאפיין Comments.

שיטה 2 – שכפול באמצעות Reflection

בשיטה זו אנחנו מבצעים שכפול באמצעות Reflection. נחלץ את המאפיינים של אובייקט המקור ונעתיק את תוכנם לאובייקט המשוכפל.

הכנה

הוסף את הusing הבא בתחילת הקובץ

using System.Reflection;

קידוד

השתמש בקוד הבא כדי לשכפל את האובייקט באמצעות Reflection

public T CloneItem<T>(T originalItem, Predicate<string> shouldCloneProperty) where T : class
{
    T result = Activator.CreateInstance<T>();

    foreach (PropertyInfo pi in typeof(T).GetProperties(BindingFlags.Public | BindingFlags.GetProperty | BindingFlags.DeclaredOnly | BindingFlags.Instance | BindingFlags.SetProperty))
    {
        if (shouldCloneProperty == null || shouldCloneProperty(pi.Name))
        {
            pi.SetValue(result, pi.GetValue(originalItem, null), null);
        }
    }

    return result;
}

כאשר:

שיטה זו מאפשרת שליטה על השכפול על-ידי predicate שמאפשר להגדיר בזמן ריצה איזה מאפיינים להעתיק.
שיטה זו לא משתמשת attributes שמודגמים בשיטה 1 ולכן גם המאפיין comments של Person יועתק.
שורה 3 – שורה זו מייצרת אובייקט מהסוג שרוצים לשכפל.
שורות 5-11 מבצעות ריצה על מאפיינים של הסוג שמשכפלים ומעתיקה את הערך של כל אחד מהמאפיינים מאובייקט המקור לאובייקט המשוכפל.
שורה 7 – במידה והוגדר predicate אז המתודה משתמשת בו כדי להחליט אם להעתיק את המאפיין. במידה והועבר null אז כל המאפיינים יועתקו.

העתקה של Entity ב-Entity Framework

שכפול של Entity בEF אפשרי בעזרת 2 השיטות המצויינות למעלה. חשוב לשים לב ל-2 נושאים בהקשר זה:

צריך לוודא שהרשומה המשוכפלת לא attached לטבלה המקורית. למרות שחשוב להכיר נקודה זו אינך נדרש לבצע פעולה כלשהי. העתקת האובייקט מטפלת בנושא זה באופן עצמאי (בגלל שלא מועתקים private members).
צריך לאפס את הproperty שמייצג את הprimarykey של הרשומה. האיפוס לא נעשה באופן אוטומטי היות והPrimaryKey הוא public member ולכן יקבל את הערך של האובייקט המקורי. כדי לגרום לEF להתייחס לEntity כרשומה חדשה, אפס את ערך זה בצורה ידנית. לדוגמא - במידה והמפתח הוא מסוג int אז איפוס הערך ל-0 יעשה את העבודה.

Tip - Bypass runtime exception “Collection was modified; enumeration operation may not execute.”

Eran Sakal — Sun, 28 Aug 2011 03:30:00 GMT

מאמר זה רלוונטי לטכנולוגיות הבאות: Silverlight4, asp.net ו-#c.

הקדמה

השגיאה שמופיעה למעלה קורת כאשר מבצעים ריצה על מערך באמצעות foreach ותוך כדי מוחקים פריט כלשהו מהמערך. פתרון שכיח אך לא אלגנטי לעקיפת השגיאה הוא ליצור מערך חדש ולאגור לתוכו את האובייקטים שרוצים למחוק. לאחר שסיימנו לאגור את האובייקטים צריך לבצע ריצה נוספת ולמחוק אותם מהמערך המקורי.

פתרון זה אומנם יעבוד אך הוא מכפיל את כמות השורות, יוצר בלאגן בקוד ובשבילי לפחות מרגיז לכתיבה.

הפתרון

הפתרון מפתיע בפשטות שלו, כדי לפתור את השגיאה צריך להבין את המקור שלה. כאשר רצים על מערך בלולאה נעשה שימוש בפקודה yield. פקודה זו מתבצעת מאחורי הקלעים והיא מאפשרת לרוץ על מערך בזמן שהוא נבנה. מחיקת פריט מהמערך תוך שרצים על המערך גורמת לשגיאה. אם אתה מעוניין לקרוא עוד על yield תכנס לקישור הבא.

כדי לעקוף את הבעיה נשתמש ב-extended method שנקראת ToList וניתן למצוא אותה ב-namespace שנקרא System.Linq.

// put this in the beginning of the file (with all the other ‘using’ statements)  
using System.Linq;

// execute foreach on a list by calling method 'ToList' on the original list
foreach (ImportedExpanse expanse in expanses.ToList())
{
    if (expanse.BillAmount <= 0)
    {
        expanses.Remove(expanse);                        
    }
}

כאשר:

שורה 2 – בפתרון זה אנחנו משתמשים בextended method. כדי שאפשר יהיה לקרוא לה חייבים שיהיה לנו using ל-System.Linq.
שורה 5 – לאחר הגרדרת ה- using ניתן לקרוא למתודה ToList. שורה זו גורמת לforeach לרוץ על מערך ולא להשתמש במנגנון ה-yield ולכן פעולת המחיקה לא פוגעת בריצה של הלולאה.

קישורים חיצוניים

קישור – הסבר פשוט וברור כיצד פועל מנגנון yield.

Silverlight – TreeView control kick-start

Eran Sakal — Tue, 23 Aug 2011 23:30:00 GMT

מאמר זה רלוונטי לטכנולוגיות הבאות: Silverlight4

לחץ כאן להורדת קוד לדוגמא של המאמר

הקדמה

במידה ורוצים להציג נתונים עם קשרים היררכים משתמשים בפקד מסוג TreeView. פקד זה מגיע כחלק מ-silverlight. במאמר זה אציג את הצעדים הנדרשים לשימוש בסיסי בפקד. במאמר הבא אראה כיצד ניתן להתאים אותו לעבודה עם MVVM Pattern.

חלק 1 - הוספת פקד מסוג TreeView

בדוגמא הבאה נגדיר מבנה נתונים בסיסי, נוסיף פקד מסוג TreeView למסך ונציג את הנתונים בעזרת הפקד שיצרנו.

הכנת הפרויקט

צור פרוייקט מסוג Silverlight Application.

הוסף רפרנס לקובץ בשם:

System.Windows.Controls.dll

קובץ MainPage.xaml

פתח את MainPage.xaml. הוסף הגדרה עבור ה-namespaces הבאים בתחילת הקובץ.

xmlns:controls="clr-namespace:System.Windows.Controls;assembly=System.Windows.Controls"
xmlns:dataHierarcy="clr-namespace:System.Windows;assembly=System.Windows.Controls"

כאשר:

הנתיב הראשון מכיל את הפקד TreeView
הנתיב השני מכיל את הפקד “HierarchicalDataTemplate”. בעזרת פקד זה נגדיר את הקשר בין הקטגוריה לתת-קטגוריות.

כעת ניתן להוסיף את הפקד. העתק את הקוד הבא לתוך ה-XAML.

<Grid x:Name="LayoutRoot" Background="White">
    <StackPanel>
        <controls:TreeView x:Name="mainTreeView">
            <controls:TreeView.ItemTemplate>
                <dataHierarcy:HierarchicalDataTemplate ItemsSource="{Binding Children}">                    
                    <TextBlock Text="{Binding Name}"></TextBlock>                    
                </dataHierarcy:HierarchicalDataTemplate>                
            </controls:TreeView.ItemTemplate>
        </controls:TreeView>
    </StackPanel>
</Grid>

כאשר:

שורה 1 – הפקד שמופיע בשורה זו אמור להיות כבר בקובץ. העתק לתוכו את שורות 2-10.
שורות 5-7 – בשורות אלו אנחנו מגדירים את התבנית שבאמצעותה יוצגו הנתונים. התבנית מסוג “HierarchicalDataTemplate” מאפשרת הגדרת קשר של קטגוריה ל-תת קטגוריות. בדוגמה זו אנחנו מגדירים שהתת-קטגוריות של האובייקט נמצאות במאפיין Children.
שורה 6 – בשורה זו הגדרנו את התבנית הויזואלית של הקטגוריות ותת-הקטגוריות (מדובר באותה תבנית). במקרה שלנו מדובר בתבנית פשוטה שבה אנחנו מציגים את התוכן של המאפיין “Name”.

סיימנו עם הUI, עכשיו נעבור להגדרת מבנה הנתונים.

קובץ CategoryItem.cs

צור קובץ בשם CategoryItem.cs והעתק לתוכו את הקוד הבא:

public class CategoryItem
    {
        public string Name { get; set; }
        public List<CategoryItem> Children { get; set; }
        public bool IsNew { get; set; }
        
        public CategoryItem(string name, params CategoryItem[] children)
        {
            this.Name = name;
            this.IsNew = false;
            this.Children = new List<CategoryItem>(children);
        }

        public CategoryItem(string name, bool isNew, params CategoryItem[] children)
        {
            this.Name = name;
            this.IsNew = isNew;
            this.Children = new List<CategoryItem>(children);
        }
    }

קובץ MainPage.xaml.cs

פתח את הקובץ MainPage.xaml.cs. העתק את הקוד הבא:

public partial class MainPage : UserControl
{
    public MainPage()
    {
        InitializeComponent();

        mainTreeView.ItemsSource = createCategoriesData();            
    }

    private System.Collections.IEnumerable createCategoriesData()
    {
        List<CategoryItem> result = new List<CategoryItem>()
        {
            new CategoryItem("Mobiles", 
                new CategoryItem("Apple",
                    new CategoryItem("Iphone 4"),
                    new CategoryItem("Iphone 5",true)),
                new CategoryItem("Samsung",
                    new CategoryItem("Galaxy S1"),
                    new CategoryItem("Galaxy S2",true))),
            new CategoryItem("Tablets", 
                new CategoryItem("Asus",
                    new CategoryItem("Asus Transformer")),
                new CategoryItem("Acer")
            )                
        };

        return result;            
    }
}

כאשר:

המחלקה שמייצגת את מבנה הנתונים “CategoryItem” יכולה להכיל מאפיינים רבים נוספים. ניתן לעשות Binding למאפיינים אלו דרך הפקד.
שורה 7 - בדוגמא זו השתמשתי בצורה “פשוטה” של העברת מבנה הנתונים לפקד. עשיתי זאת כדי לפשט את הדוגמא. ביצעתי פניה ל'”ItemSource” ב-Constructor לצורך איתחול הנתונים.
שורה 10 – יוצרת מבנה נתונים סטטי. באפליקציות אמיתיות הנתונים יטענו ממקור נתונים. במאמר הבא אראה כיצד ניתן ליצור מבנה נתונים היררכי מתוך טבלה בבסיס הנתונים (שהיא שטוחה כברירת מחדל).

סיימנו. הרץ את הפרוייקט. אתה אמור לראות משהו שנראה כך:

חלק 2 – ביצוע פעולות נוספות על הפקד TreeView

סעיף זה מכיל תיאור לא מפורט של פעולות שכיחות שעושים עם הפקד TreeView.

ביצוע פעולות על הפריט הנבחר באמצעות קוד

לצורך קבלת הפריט הנבחר בצע קריאה למאפיין “SelectedItem”.

קבלת אובייקט TreeViewItem עבור אובייקט ממערך הנתונים

הפקד TreeView מייצר אובייקט מסוג TreeViewItem עבור כל אובייקט במבנה הנתונים שאנחנו מעבירים. דרך אובייקט זה ניתן לבצע פעולות כמו להרחיב את הפריט (מאפיין IsExpanded), להשפיע על העיצוב שלו ועוד.

mainTreeView.UpdateLayout();

TreeViewItem treeViewItem = mainTreeView.ItemContainerGenerator.ContainerFromItem(mainTreeView.SelectedItem) as TreeViewItem;

if (treeViewItem != null)
{                                
    // do what you want
}

כאשר:

שורה 1 – נועדה להבטיח שהתצוגה של העץ עדכנית. מבלי להכנס לסיבה אובייקט זה לא יווצר במידה והעץ לא מציג את הנתון המבוקש.
שורה 3 – אנחנו משתמשים במאפיין “ItemContainerGenerator” לביצוע ההמרה.
שורה 5 – חשוב תמיד לבצע בדיקה שהאובייקט חזר. יש מספר סיבות עבורן האובייקט יכול לא לחזור:
- האובייקט המבוקש לא קיים או לא מוצג על המסך.
- הפקד עדיין לא נטען, משמע ביצעתם את הפעולה לפני שהאירוע “Loaded” של הפקד נזרק.
- האובייקט מוצג על המסך אבל התצוגה עדיין לא התעדכנה. לצורך כך אנחנו מבצעים קריאה ל”UpdateLayout” בשורה 1

רישום לאירוע כשהמשתמש בוחר פריט בפקד

לצורך קבל חיווי כשהמשתמש מחליף את הפריט הנבחר הרשם לאירוע”SelectedItemChanged”.

עיצוב שונה בין רמות שונות בעץ

כדי ליצור עיצוב שונה בין הפריטים ברמה הראשונה לבין התת-פריטים נעזר בדוגמא הבאה. החלף את הקוד בXAML עם הקוד הבא:

<controls:TreeView x:Name="mainTreeView">
    <controls:TreeView.ItemTemplate>
        <dataHierarcy:HierarchicalDataTemplate ItemsSource="{Binding Children}">
            <dataHierarcy:HierarchicalDataTemplate.ItemTemplate>
                <DataTemplate>
                    <TextBlock FontStyle='Italic' Text='{Binding Path=Name}' />
                </DataTemplate>
            </dataHierarcy:HierarchicalDataTemplate.ItemTemplate>
            
            <TextBlock Text='{Binding Path=Name}' FontWeight='Bold' />
        </dataHierarcy:HierarchicalDataTemplate>
    </controls:TreeView.ItemTemplate>
</controls:TreeView>

כאשר:

בדוגמא זו הפריטים ברמה 1 יוצגו כשהם מודגשים ושאר תתי-הפריטים יוצגו כשהם מוטים (תצלום מסך מצורף בהמשך)
שורות 4-8 – בשורות אלו הגדרנו את המאפיין “ItemTemplate” של הפקד “HierarchicalDataTemplate”. מאפיין זה מכיל את התבנית שבה יוצגו התת-פריטים.
שורה 10 – בשורה זו הגדרנו את התבנית שבה יוצג הפריט הנוכחי.

לאחר הרצת הקוד מחדש האפליקציה אמורה להראות כך:

לסיכום

במאמר זה ראינו כיצד להציג נתונים היררכים באמצעות פקד מסוג TreeView. לצערי הפקד שמגיע עם silverlight מוגבל ביכולות ומקשה על שילובו באפליקציות עסקיות ובמיוחד באפליקציות שמפותחות לפי עקרונות MVVM. במאמר הבא אני אראה כיצד ניתן להתאים אותו לשימוש באפליקציות MVVM.

לחץ כאן להורדת קוד לדוגמא של המאמר

קישורים חיצוניים:

קישור 1 (אנגלית) – קישור זה מכיל מדריך בסיסי מקיף לשימוש ב-TreeView. המדריך מראה כיצד ניתן ליצור את הפקד באמצעות “Expression Blend”, כיצד לשנות את הstyle של הפקד ועוד.

קישור 2 (אנגלית) – מדריך לביצוע פעולות מתקדמות כגון מציאת TreeViewItem עבור אובייקט מידע, הקשבה ללחיצה עם העכבר על פריט ועוד.

Delegates in daily use - Part I

Eran Sakal — Mon, 27 Sep 2010 00:01:00 GMT

למרות שהרבה אנשים מכירים את המושג Event המתבסס על delegates, המושג delegate פחות שכיח. אנשים אומנם שמעו על המושג אבל לא בהכרח יודעים מה זה, איך עובדים עם זה והכי חשוב - איך זה יכול לשרת אותנו בפיתוח.

תוכן המאמר

delegate – הגדרה כללית
שימוש מבחינת syntax
דוגמאות בסיסיות לצורך הבנה.

הגדרה כללית

delegate הינו אובייקט שעוטף מתודה. את הdelegate ניתן להעביר בתור פרמטר למתודות אחרות או להגדיר כproperty של אובייקט. בכל שלב שהוא ניתן להריץ את המתודה באמצעות פניה לdelegate מבלי לדעת איזו מתודה רצה בפועל.

לצורך הדוגמא נסתכל על כפתור בממשק גרפי. כאשר לוחצים על כפתור אנחנו רוצים שתופעל לוגיקה כלשהי. במילים אחרות אנחנו רוצים שבלחיצה על כפתור תורץ מתודה ספציפית. מה הבעיה? שהכפתור לא מכיר את המתודה שאנחנו רוצים להריץ. בדיוק למצב זה קיים delegate. כל מה שצריך לעשות זה ליצור כפתור ולהעביר אליו את המתודה שרוצים שתרוץ לאחר לחיצה.

Syntax – כיצד מגדירים בקוד

את ה-delegate מגדירים בדומה לחתימה של מתודה ללא תוכן.

[scope] delegate [return-type] delegateName ([parameters]);

כאשר:

[scope] – (אופציונלי). הגדרת רמת החשיפה של הdelegate (ערכים אפשריים private / protected / public / internal).
[return-type] – מתודה שרוצים להעביר לdelegate זה חייבת להחזיר את הערך הזה.
[parameters] – מתודה שרוצים להעביר לdelegate זה חייבת לקבל את פרמטרים אלו לפי סדר.

הערות:

שים לב למילה השמורה delegate לפיה יודע הCLR כי מדובר בהגדרה של delegate ולא במתודה רגילה.
את הdelegate ניתן להגדיר באופן ישיר מתחת לnamespace או כחלק מהגדרה של מחלקה.

דוגמאות

   1: public delegate void LogDelegate(string content);

בדוגמא זו הגדרנו delegate בשם "LogDelegate". נהוג להוסיף את המילה "Delegate" בסוף השם לצורך קריאות. בעזרת delegate זה ניתן להעביר מתודות שלא מחזירה כלום (void) ומקבלות פרמטר אחד מסוג string.

   1: delegate bool TryFormatNumberDelegate(int number, out string formatterNumber);

בדוגמא זו הגדרנו delegate בשם "TryFormatNumberDelegate". בעזרת delegate זה ניתן להעביר מתודות שמחזירות ערך bool ומקבלות פרמטר מסוג int ופרמטר מסוג out string.

איך יודעים איזו מתודה מתאימה לdelegate

ניתן להעביר מתודה למשתנה מסוג delegae כלשהו רק במידה והחתימה של המתודה ושל הdelegate זהים. משמע: ה-return type, מספר הפרמטרים שהמתודה מקבלת והסוג של הפרמטרים זהים לאלו של ה-delegate.

מי בודק אם העברנו מתודה מתאימה?

במידה ולא העברנו מתודה מסוג מתאים לdelegate הקוד לא יעבור קומפיליציה - מכאן שאתם לא יכולים לטעות. תזמון הבדיקה אינו מקרי וזאת היות ובזמן ריצה הקוד שמקבל מצביע למתודה מסתמך על כך שהוא איזה פרמטרים צריך להעביר ואיזה ערך היא מחזירה.

שימוש בdelegate

לאחר שהגדרנו delegate בקוד ניתן להשתמש בו כמו סוגים אחרים של אובייקטים שאנחנו מכירים – string, int, DateTime. את הdelegate ניתן להגדיר כמשתנה במתודה, כפרמטר של מתודה או מאפיין של מחלקה.

נסתכל על הדוגמא הבאה. בדוגמא זו יצרנו מחלקה "FileHandler" שמקבלת נתיב לקובץ, קוראת את התוכן שלו ומריצה לוגיקה שהועברה לה ב-delegate בלי לדעת מה הלוגיקה עושה.

   1: public class FileHandler   2: {   3:    public delegate void HandleContentDelegate(string content);   4:     5:    public void HandleFile(string filePath, HandleContentDelegate handleContentMethod)   6:    {   7:        if (File.Exists(filePath))   8:        {   9:            string content = File.ReadAllText(filePath);  10:    11:            if (handleContentMethod != null)  12:            {  13:                handleContentMethod(content);  14:            }  15:        }  16:    }  17: }

הסבר קוד:

שורה 3 – בשורה זו הגדרנו delegate בשם "HandleContentDelegate" שמתאים לכל מתודה שלא מחזירה כלום (void) ומקבלת string כפרמטר יחיד.
שורות 5 עד 16 – מגדירות מתודה בשם "HandleFile". מתודה זו מקבלת פרמטר "filePath" (נתיב לקובץ), קוראת את התוכן של הקובץ ומעבירה את התוכן למתודה שהועברה בפרמטר "handleContentMethod". שימו לב שבגלל שאנחנו מכירים את החתימה של הdelegate אנחנו יודעים בוודאות שהמתודה צריכה לקבל מחרוזת ולא להחזיר ערך. מכאן שלא באמת רלוונטי עבורנו איזו מתודה הועברה לdelegate.

הערות והבהרות:

שורה 13 – מבצעת קריאה לdelegate. בפועל מתבצעת קריאה למתודה שהועברה בתור פרמטר. שימו לב שקריאה לdelegate נעשית בדיוק כפי שקוראים למתודה.
בקוד זה אני מדגים קונבנציה שכיחה של שמות (לא חובה אבל מומלץ):
- שורה 3 - שם הdelegate מסתיים במילה "Delegate"
- שורה 5 - פרמטר מסוג delegate מסתיים עם המילה "Method".
שורה 11 – לפני שאנחנו קוראים לפרמטר מסוג delegate חשוב לבדוק שהוא מכיל מתודה כלשהי ולא שווה לnull. זאת היות ומדובר בreference type.

הדוגמא הבאה מראה שימוש בFileHandler שכתבנו בדוגמא הקודמת. בדוגמא זו אנחנו קוראים פעמיים לFileHandler. פעם אחת אנחנו מעבירים מתודה שמציגה את התוכן של הקובץ על המסך ופעם שניה מציגה אותו בחלון DEBUG שבVisual Studio. שימו לב שהמחלקה FileHandler נכתבה בלי לדעת את הלוגיקה שתורץ בתוכה.

   1: public class Test   2: {   3:   public static void DisplayOnScreen(string messageToShow)   4:   {   5:       MessageBox.Show(messageToShow);   6:   }   7:     8:   public void DisplayOnImmediate(string messageToShow)   9:   {  10:       System.Diagnostics.Debug.Write(messageToShow);  11:   }  12:    13:   public void Execute()  14:   {              15:       string filePath = @"c:\test.txt";  16:       FileHandler fileHandler = new FileHandler();  17:         18:       fileHandler.HandleFile(filePath, DisplayOnScreen);  19:       fileHandler.HandleFile(filePath, this.DisplayOnImmediate);  20:   }                   21: }

הסבר קוד:

שורה 13 – המתודה "Execute" – קוראת לFileHandler פעמיים.
- בשורה 18 - מעבירה כפרמטר את המתודה DisplayOnScreen.
- בשורה 19 - מעבירה כפרמטר את המתודה ShowAsOutput.

שאלות-תשובות

שאלה
האם שמות הפרמטרים חייבים להיות זהים במתודה ובdelegate?

תשובה
לא. הפרמטר הראשון בdelegate נקרא "content" ואנחנו מעבירים מתודות בשורות 18 ו-19, שהפרמטר הראשון שלה נקרא "messageToShow". זה מצב תקין היות והCLR מחפש התאמה בסדר של הפרמטרים והסוג שלהם מבלי לדרוש ששמות הפרמטרים יהיו זהים.

סיכום

בחלק זה ראינו כיצד מגדירים ומשתמשים בdelegate מבחינת syntax.

בשבוע הבא אפרסם מאמר המשך עם דוגמאות שכיחות/פרקטיות לשימוש בdelegates.

ערן.

Javascript – How to compare two object instances

Eran Sakal — Sat, 11 Sep 2010 21:07:00 GMT

מאמר זה מראה כיצד ניתן להשוות בין נתונים של 2 אובייקטים שונים ב-javascript.

מוטיבציה

בשנה האחרונה היו 2 מצבים בהם נדרשתי ליכולת זו:

מצב 1 - פניתם לבסיס הנתונים וקיבלתם אובייקט המכיל נתונים על לקוח. לאחר זמן מסויים פניתם שוב לבסיס הנתונים ואתם מעוניינים לדעת אם הנתונים השתנו או לא.
מצב 2 - יש לכם מנגנון שמנהל היסטוריה של פעולות. כל פעולה מיוצגת באמצעות אובייקט המכיל אוסף של משתנים. כדי למנוע מאותה הפעולה להתבצע פעמים אתם רוצים להשוות בין הפעולה האחרונה שנעשתה לבין הפעולה שהמשתמש מנסה לעשות.

במצבים שתוארו למעלה מדובר ב-2 אובייקטים שונים (מקומות שונים בזיכרון) ואנחנו מעוניינים לדעת אם הנתונים שלהם זהים או לא. אי-אפשר לבצע פעולת השוואה רגילה היות והשוואה רגילה בreference value משווה כתובות בזיכרון והתוצאה תמיד תהיה שהאובייקטים לא שווים. לכן דרוש פתרון חכם יותר שמשווה את המאפיינים של האובייקטים.

פתרונות קוד

פתרון 1

השתמשו בפונקציה הבאה להשוות בין האובייקטים. הפונקציה לא נכתבה על-ידי אך היות והשתמשתי בה לראשונה לפני שנה אין לי אפשרות למצוא את המקור ולתת לו קרדיט.

function compareObjects(x,y){ 

    x = (typeof x == 'undefined') ? null : x;
    y = (typeof y == 'undefined') ? null : y;
    
    if (x == null || y == null)
    {
        return (x == null && y == null)
    }
    
    for (var p in y) { 
        if(typeof(y[p]) !== typeof(x[p])) return false; 
        if((y[p]===null) !== (x[p]===null)) return false; 
        switch (typeof(y[p])) { 
            case 'undefined': 
                if (typeof(x[p]) != 'undefined') return false; 
                break; 
            case 'object': 
                if(y[p]!==null && x[p]!==null && (y[p].constructor.toString() !== x[p].constructor.toString() || !y[p].equals(x[p]))) return false; 
                break; 
            case 'function': 
                if (p != 'equals' && y[p].toString() != x[p].toString()) return false; 
                break; 
            default: 
                if (y[p] !== x[p]) return false; 
        } 
    } 
    return true; 
}

דוגמאות שימוש

var instance1 = { name : 'Eran', aRank : [1,3,5] };
var instance2 = { name : 'Liron', aRank : [1,3,5] };
var instance3 = { name : 'Liron', aRank : [1,3,5] };


var isEqual = compareObjects(instance1,instance2); // result false (name is not the same)
isEqual = compareObjects(instance2,instance3); // result true

פתרון 2 (אלגנטי יותר אך לא בהכרח נחוץ)

מפתחים רבים אוהבים פתרונות אלגנטים שבהם הפעולות נעשות ישירות על האובייקטים. ב-C# המציאו עבור זה יכולת בframework 3 שנקראת Extension Methods. יכולת זו קיימת בjs באמצעות הוספת הפונקציה לprototype.

בפתרון זה נוסיף פונקציה שנקראת “equals” לכל אובייקט. כפי שמעידה הכותרת, הפתרון אלגנטי ולרוב מורכב יותר מהנדרש. אבל טוב לדעת שהוא אפשרי.

איך עושים זאת?

כל האובייקטים ב-javascript יורשים ממחלקה שנקראת Object. בנוסף, לכל מחלקה יש מאפיין שנקרא prototype. דרך prototype אפשר להגיע לכל המאפיינים של כל המחלקות מאותו הסוג (כולל אלו שיווצרו בעתיד). הוספת פונקציה ל – Object.prototype תתווסף לכל המאפיינים של כל האובייקטים (היות וכולם יורשים מ-Object).

נוסיף את הפונקציה הבאה מיד אחרי הפונקציה שמפתרון 1:

Object.prototype.equals = function(compareTo)
{
    return compareObjects(this,compareTo);
}

דוגמאות שימוש

var instance1 = { name : 'Eran', aRank : [1,3,5] };
var instance2 = { name : 'Liron', aRank : [1,3,5] };
var instance3 = { name : 'Liron', aRank : [1,3,5] };

var isEqual = instance1.equals(instance2); // result false (name is not the same)
isEqual = instance2.equals(instance3); // result true

Site configuration manager - Easy to implement and use

Eran Sakal — Wed, 01 Sep 2010 00:00:00 GMT

כל אתר אינטרנט מכיל קונפיגורציות. השימוש בקובצי קונפיגורציות שכיח היות והוא מאפשר להשפיע על התנהגות האתר מבלי שצריך לקמפל את האתר כל פעם מחדש. לכן דאגו מתכנתי microsoft להוסיף מנגנון קונפיגורציה ב-asp.net וקראו לו בשם appsettings. עד כאן אני מניח שאני לא מחדש יותר מדי.

מאמר זה לא מדבר על appsettings מכמה סיבות, כשהעיקרית ביניהן היא שמאוד קל ללמוד איך לעשות זאת ויש אלפי מאמרים שמראים איך. אז על מה המאמר בעצם? מנסיוני, מתכנתים נזקקים לעיתים קרובות לניהול קונפיגורציה משוכלל יותר, אבל מסתפקים בappsettings פשוט כי הוא שם. בהמשך המאמר אני מסביר את ההבדלים בין התשתיות.

בכל מקום עבודה אליו הגעתי בשנים האחרונות, אחד הפיתוחים הראשונים שלי היה תשתית לניהול קונפיגורציות. הדרישה המרכזית: לבנות תשתית שתנהל את כל הלוגיסטיקה כגון טעינת הקובץ לזיכרון, ניטור הקובץ במידה והוא משתנה, שמירת נתונים מהאפליקציה חזרה לקובץ וניהול ThreadSafe.

למי התשתית מיועדת

התשתית מיועדת לכל אתר שהוא לא מסוג "שגר ושכח" (אתרים קטנים שלאחר שמעלים אותם לאוויר הם לא משתנים לאורך זמן רב). התשתית עצמה פשוטה לשימוש למפתחים מכל הרמות.

מאיפה מורידים את התשתית

הכנסו לקישור שמופיע בסוף המאמר. הורידו את התשתית והוסיפו אותה לאתר שלכם.

דרישות מרכזיות מתשתית קונפיגורציה

סעיף זה מכיל רשימה של דרישות מרכזיות מתשתית לניהול קונפיגורציה.

דרישות פונקציונאליות

רכיב תשתיתי שיאפשר מיפוי של נתוני קונפיגורציה מקובץ לאובייקט בזיכרון.
השליטה במבנה הנתונים של הקונפיגורציה צריכה להימצא בידי המתכנת אשר משתמש בתשתית.
הרכיב צריך לשמור על סנכרון בין הקובץ לאובייקט בזיכרון. שינוי בקובץ צריך להשתקף במיידית באובייקט שבזיכרון - מבלי להשפיע על התנהלות האפליקציה.
אפשרות לעריכת הנתונים בקובץ הקונפיגורציה ישירות מהאפליקציה באמצעות הרכיב התשתיתי.

דרישות טכנולוגיות/תוכנה

הרכיב צריך לדעת לעבוד בסביבה מרובת משתמשים (Thread-safe) – למי שלא מכיר, סביבה שבה קוראים וכותבים בו זמנית לרכיב.
יש לאפשר שיהיו מספר העתקים של הרכיב בו-זמנית באפליקציה כאשר כל העתק ינהל קובץ קונפיגורציה אחר. לדוגמא רכיב אחד ינהל קובץ משתמשים ורכיב אחר קובץ הגדרות אתר.
הרכיב יכתוב נתונים טכנים ללוג על-מנת שאפשר יהיה לאתר תקלות בזמן מהיר.

רגע לפני - פתרונות קיימים ב-asp.net

הפתרון השכיח - שימוש ב-app settings

כאמור, הפתרון הפשוט והמוכר לניהול קונפיגורציות הוא appsettings. למי שלא מכיר, app settings ממוקם בקובץ web.config שם נשמרת הקונפיגורציה בצורה של אוסף אלמנטים כאשר כל אלמנט מורכב ממפתח (key) וערך (value) וזה נראה כך:

<appSettings>
    <add key="Global.MaintainanceMode" value="true"/>
    <add key="Site.Title" value="Eran Sakal - Blog"/>    
 </appSettings>

לעבודה עם appsettings יש מספר חסרונות:

שינוי של ה-appsettings משפיע על כלל האפליקציה (מבצע ריסטרט לאפליקציה). אחת ההשלכות של זה הינו איבוד הsessions של המשתמשים המחוברים באותו הרגע.
מבנה הנתונים של הappsettings קבוע (אוסף מפתחות וערכים) ולא משקף בהכרח את המבנה הנדרש עבור הרכיב המדובר. לדוגמא, אין אפשרות ליצור היררכיה של נתונים.
היות וה-appsettings משותף לכלל האפליקציה. נוצר ערבוב בין הקונפיגורציות של המודולים השונים. מצב זה יכול להוביל להתנגשות בין קונפיגורציות וקושי לשייך קונפיגורציה למודול הרלוונטי.
לא ניתן לבצע עדכון של קונפיגורציה מהזיכרון לקובץ - web.config (אני כותב סעיף זה עם הסתייגות קלה היות וישנה דרך אך היא לא מומלצת ולא טובה).

כמובן שישנם מצבים שבהם נוח ונכון להשתמש בapp settings:

כשרוצים להגדיר הגדרות של האפליקציה עצמה. דוגמאות:
- אם יש טופס צור קשר – רשימת המיילים אליהם יישלחו הפניות מהטופס.
- אם יש קבצים בשימוש האפליקציה – כתיבת הנתיב המלא לקובץ.
- אם יש פרסומות באתר ורוצים שתהיה אפשרות להעלים אותם או להציג אותם בצורה מהירה.
פיתוח מהיר - קל ואינטואיטיבי להשתמש בappsettings.

מאמר זה לא מתמקד בעבודה עם appsettings ולכן לא ארחיב על השימוש. ניתן לקרוא את המאמר החיצוני הבא המכיל דוגמאות קוד לנושא.

פתרון מתקדם יותר - שימוש ב-config section

אפשרות זו פחות מוכרת ולכן גם פחות בשימוש. למי שלא מכיר, ניתן להגדיר מקטע XML בקובץ web.config ויש לכם שליטה מלאה על המבנה שלו. מדובר בתשתית שמאפשרת לכם לגשת בקלות אל הנתונים מהאפליקציה. אפשרות זו פותרת 2 חסרונות גדולים בעבודה עם app settings והם:

המתכנת יכול להגדיר את מבנה הXML בהתאם לצורכי המודול.
ניתן להגדיר מקטעים נפרדים עבור כל מודול ובכך למנוע ערבוב של הקונפיגורציות. הקוד הבא מראה דוגמא לconfig section:

<SiteConfiguration>
  <Global MaintainanceMode="true"></Global>
  <Information>
    <Title>Eran Sakal - Blog</Title>
  </Information>
</SiteConfiguration>

פתרון זה אומנם נותן מענה לדרישות נוספות מהרשימה אך לא לכולם. מאמר זה לא מתמקד בעבודה עם config section. ניתן לקרוא את המאמר החיצוני הבא המכיל דוגמאות קוד לנושא.

תשתית חכמה לניהול קונפיגורציות

התשתית במאמר זה, "XmlConfiguration Manager", עונה על כלל הדרישות שמוגדרות למעלה. למעשה, היא נכתבה על-בסיס הדרישות הנ"ל. הטבלה הבאה רשימה פונקציונלית של הדרישות:

Configuration Scope – אפשרות להגדיר קונפיגורציה לכל מודול בנפרד.
Behavior on changes in configuration file – סנכרון הנתונים עבור המודול הרלוונטי מבלי להפריע להתנהלות האפליקציה.
Configuration data structure – גמישות בהגדרת מבנה הנתונים של הקונפיגורציה עבור כל מודול.
Multiple configuration handling – שימוש במספר קונפיגורציות באפליקציה בו-זמנית למספר מודולים מבלי שתהיה התנגשות ביניהם.
Behavior on configuration error – בידוד התקלה במקרה של קונפיגורציה שגויה כך שרק פעולות הקשורות ישירות לקונפיגורציה הבעייתית יושפעו.
Updating configuration file from application - תמיכה בביצוע עדכון הפוך של קובץ הקונפיגורציה מתוך האפליקציה.
Multi-threaded environment – עבודה בסביבה מרובת משתמשים (כגון אתרי אינטרנט).
Technical Logging – אינטגרציה עם תשתית logging באמצעותה אפשר לנטר את המתרחש בתשתית.
Ease of use - שימוש בפרוטוקלים מוכרים על-מנת למזער את זמן הלמידה והשימוש בתשתית.

ניתן לצפות בטבלת השוואה בין מימוש הדרישות בתשתית זו לבין המימוש בכלים appsettings/config section.

* לחצו על התמונה להגדלה

דרישות קדם לשימוש בתשתית

על-מנת לעבוד בתשתית צריך להכיר שימוש בXPath. התשתית משתמשת בפרטוקול XML לשמירת נתונים בקובץ הקונפיגורציה כאשר הכי קל להשתמש בXPath כדי להמיר את הנתונים ממבנה XML לאובייקט ב-CSharp וחזרה. מי שמכיר את העבודה עם XPath ורק צריך רענון מוזמן לגלוש לקישור הבא. אם אינכם מכירים את הנושא תגלשו לקישור הבא המכיל מדריך מפורט וברור.

עיקרי תשתית – XML Configuration Manager

כל שינוי שמבוצע בקובץ הקונפיגורציה מנוטר אוטומטית והתשתית מעדכנת את האובייקט בזיכרון.
התשתית מבצעת כתיבה של נתונים טכנים ללוג באמצעות Log4net.
התשתית מפותחת על-בסיס עקרונות של הנושאים Thread Safety ו-ExceptionHandling.
הקוד מכיל תיעוד מלא.

התשתית מורכבת ממחלקה מרכזית בשם XmlConfigurationManager.

* לחצו על התמונה להגדלה

כיצד מטמיעים את התשתית

הרשימה הבאה מראה את הצעדים הנדרשים להטמעת התשתית בפרויקט.

הוסיפו את התשתית לאתר (בצעו reference או מקמו בספריית bin).
צרו קובץ XML שמכיל את הנתונים שלכם (להלן – קובץ הקונפיגורציה)
הגדירו מחלקה שמייצגת את מבנה הנתונים הנדרש (להלן – מחלקת הנתונים).
הגדירו מחלקה שתנהל את סנכרון הנתונים (להלן – מחלקת הניהול). בצעו ירושה למחלקה XmlConfigurationManager והעבירו כgeneric parameter את מחלקת הנתונים.
ממשו את המתודה האבסטרקטית SyncInstanceForRead. מתודה זו אחראית לייצר אובייקט נתונים מקובץ הקונפיגורציה.
בצעו איתחול לאובייקט באחת מ-2 הדרכים הבאות:

שימוש ב-Constructor – הצורה הסטנדרטית. ניתן להעביר את הנתיב של הקובץ באיתחול האובייקט. במצב כזה קובץ הנתונים ייקרא מיידית.
קריאה למתודה Initialize – שיטה זו מומלצת אם מעוניינים להרשם קודם לאחד מהאירועים (פירוט על האירועים בהמשך הסעיף).

כיצד משתמשים בתשתית

הרשימה הבאה מכילה מתודות ואירועים שדרכם ניגשים לקונפיגורציה.

המתודות הבאות משמשות לעבודה מול מחלקת הניהול:
- TryGetData – מתודה זו מאפשרת קבלה של אובייקט הנתונים. המתודה מוודאת קודם שהנתונים עדכניים. שימוש בשיטה TryGetData מכווין לטיפול נכון במצבים שבהם הנתונים לא זמינים.
- IsValid – מתודה זו משמשת במצבים בהם רוצים לדעת אם הנתונים זמינים אבל לא צריכים להשתמש בנתונים אלו.
- SaveConfiguration – מתודה זו מאפשרת שמירה של שינויים שנעשו באובייקט הנתונים ישירות לקובץ הקונפיגורציה. כדי להשתמש במתודה זו צריך לממש את הממשק 'ISupportSave'.
האירועים הבאים מאפשרים התערבות בתהליך עדכון הנתונים מהקובץ לזיכרון
- DataChanging – אירוע זה מאפשר להציץ על אובייקט הנתונים החדש לפני שהוא מתעדכן בזיכרון ובמידת הצורך לכפות ביטול של פעולת העדכון.
- DataChanged – אירוע זה נקרא לאחר סנכרון ונועד למצבים מתקדמים כגון עדכון אובייקט אחר שתלוי בנתוני הקונפיגורציה שהשתנו.

דוגמא לקובץ קונפיגורציה

בקישור הבא צירפתי קונפיגורציה לדוגמא שמנוהלת באמצעות התשתית. מדובר בקונפיגורציה שלקוחה מאתר מוכר ואחראית על איזורי הפרסומות באתר. הקונפיגורציה אולי תיראה לכם פשוטה אבל זו בדיוק המטרה – לבנות קונפיגורציה במבנה XML שמותאם לצרכי האתר בקלות.

לחצו כאן לצפיה בדוגמא של קובץ קונפיגורציה

הורדת התשתית

במאמר זה הראתי תשתית שבאמצעותה תוכלו לנהל בקלות ובגמישות קונפיגורציות באתרכם. בקישור הבא ניתן להוריד את הרכיב כולל קוד מקור ודוגמאות שימוש. מקווה שתמצאו את התשתית מועילה עבורכם. תרגישו חופשי לשאול שאלות.

לחצו כאן להורדת התשתית

במידה והקישור למעלה לא עובד – הורידו באופן ישיר מהקישורים הבאים:

ערן.

How to avoid spaghetti code in javascript

Eran Sakal — Thu, 26 Aug 2010 01:54:00 GMT

javascript מאוד פופולרית באתרי web. כל הדפדפנים השכיחים תומכים בjavascript. כמעט כל אתר משתמש בjavascript לבצע פעולות UI בדפדפן. אז מדוע מעטים האנשים שחושבים שהיא שפה נחמדה לתכנות?

בתור התחלה קשה לדעת איזה סוג שפה היא. מרבית האנשים יגידו שהיא שפה פונקציונלית. אבל אפשר להגדיר בה אובייקטים, האם זה אומר ש-JS היא אולי שפה מכוונת עצמים (OOP)? אבל אין בה ירושה – אז איך היא תהיה OOP? בגלל שJS היא שפה מאוד כללית עם מעט מאוד מגבלות, ובגלל שקשה לקטלג אותה לפרדיגמת תכנות כלשהי, נוצר חוסר בהירות לגבי השימוש בה. התוצאה המתקבלת לרוב היא קוד ספגטי.

מאמר זה הינו הראשון מתוך סדרת מאמרים בנושא כתיבה פרקטית בשפת javascript באתרי web. בחרתי להראות במאמר זה כיצד מגדירים אובייקטים בJS ובכך להמנע מקבצים ארוכים המכילים כמויות של פונקציות גלובליות - ליכולת זו יתרונות רבים:

קריאות קוד – חלוקה לאובייקטים יוצרת הפרדה בין הפונקציות לפי מודולים.
מפשט את התחזוקה של הקוד.
מאפשר לבצע בקלות code reuse.
תמיכה בכימוס (Encapsulation) – מאמר זה לא מרחיב על יתרון זה אך הוא מהווה הקדמה לנושא. במאמר נפרד אראה כיצד ניתן להגדיר משתנים/פונקציות מסוג private. יכולת זו תאפשר יצירה של אובייקטים אוטונמים.

בסעיף הבא אני מסביר בקצרה מהי שפה דינמית ומה הכוח הטמון בשפה JS. מי שרוצה לעבור למימוש מוזמן לדלג על ההקדמה ולעבור ישירות לסעיף שאחרי.

רגע לפני – javascript = שפה דינמית?

השפה javascript היא שפה דינמית. שפה דינמית היא שפה עילית שמבצעת בזמן ריצה פעולות שמבוצעות בדרך-כלל בזמן ההידור (compliation) כגון הגדרת משתנים, יצירת פונקציות חדשות, הרחבת אובייקטים קיימים. כל הפעולות הנ"ל מתבצעות בזמן ריצה.

למה חשוב לדעת שjavascript היא שפה דינמית? מי שלא עבד עם שפה דינמית ולא מכיר את היתרונות בשפה דינמית נוטה לחשוב שjs היא שפה חלשה , כתובה לא נכון, מעודדת שגיאות ובעיות שקשה לדבג. אחרי שלומדים לנצל את יתרונות השפה הדינמית מגלים שהיא מאפשרת כלים פשוטים אך עם זאת עוצמתיים – צריך רק לאזור אומץ ולהיות סבלניים ופתוחים לנושא.

אומנם היום אני חכם גדול, אבל עד לפני מספר חודשים אפשר להגיד שהייתי סקריפטופוב רציני. אני מתכנת 4 שנים בweb וכתבתי לא מעט ב-JS אבל תמיד ניסיתי למזער את השימוש עד כמה שאפשר. לפני זמן מה קיבלתי עבודה ש"אילצה" אותי לפתח מערכת בjs עם ארכיטקטורה מורכבת ודרישות למודולריות, טיפול נכון בשגיאות (מישהו אמר logging ב-javascript?), ניהול אירועים, עמידה בעומסים ועוד הרבה מטעמים נוספים. בהתחלה נבהלתי כל-כך שסירבתי לקבל את העבודה. אך בסוף התרצתי ותוך כדי עבודה גיליתי שיש לא מעט כלים שהרוב לא מכירים והם יכולים להיות מאוד יעילים בתכנות בJS. ואלו הנושאים שארחיב עליהם במאמרים הבאים:

שימוש נכון באובייקטים בקבצי JS (מאמר זה)
מספר דרכים ליצירת "מחלקות"
הגדרת scoping באפליקציה (ובפרט private members).
שימוש ב-Regular Expression.
טיפול נכון ומניעה מקדימה של שגיאות.
עבודה עם namespaces.
יצירת מנגנון באירועים (events).
יכולות מתקדמות בשפה דינמית.

חזרה לנושא – כיצד מייצרים אובייקט

האם אתם מתכנתי web? אם כן אז כנראה כתבתם בשפת js. אני מניח שיש לכם בממוצע 10-40 פונקציות בכל אתר. ומשתנים (var) גלובלים – בטח גם כאלה יש בקוד? אם התשובה היא כן אז יש לי שאלה אליכם – האם כל הפונקציות מוגדרות בעמוד או בקובץ נפרד? האם הקפדתם לקבץ משתנים ופונקציות ליחידות עצמאיות (אובייקטים)? תסתכלו על הקובץ הבא (לקוח מאתר מוכר בארץ) – קובץ זה ממחיש כתיבה שכיחה (ומבלוגנת) של קוד js באתרים.

קובץ לדוגמא עם קוד JS מבולגן

בסוף המאמר הוספתי קובץ שמראה קוד לדוגמא מחולק לאובייקטים.

קיבוץ פונקציות ומשתנים לאובייקטים

הגדרת האובייקט מבוססת על פורמט שנקרא JSON, או בשמו המלא Javascript Object Notation.

הגדרה פשוטה

הדוגמא הבאה מראה הגדרה של אובייקט עם מספר מאפיינים:

var oUser = { sName : 'eran', nAge : 30, bMarried : true };
// alternative syntax (the same meaning as the above)
var oUser = { 'sName' : 'eran', 'nAge' : 30, 'bMarried' : true };

כאשר:

בJSON האובייקט עטוף בסוגריים מסולסלים.
כל מאפיין מורכב משם מאפיין וערך כאשר הם מופרדים באמצעות הסימן נקודותיים.
כל זוג מאפיינים מופרד באמצעות הסימן פסיק.
את שם המאפיין ניתן להגדיר בלי/עם מרכאות – המשמעות זהה.
סוג המאפיין נגזר מהערך שהושם לתוכו (לדוגמא bMarried הוא ערך בוליאני ו-nName הוא מחרוזת).
כתיבת אובייקט בפורמט json מגדירה את מבנה האובייקט ובsyntax הנ"ל האובייקט מאותחל אוטומטית לתוך המשתנה (בדוגמא למעלה לתוך oUser). לא ניתן ליצור אובייקטים נוספים באמצעות שימוש במילה השמורה new.

דוגמא לעבודה עם האובייקט:

// change user name
oUser.sName = "liron";

הגדרת מערך של אובייקטים

בדוגמא זו נראה כיצד מגדירים אובייקט שהוא מערך של אובייקטים:

var arrColors = [ 'red', 'green', 'yellow' ];
var arrCar = [ {sManufacturer : 'toyota', sModel : 'corolla'}, { sManufacturer : 'subaro', sModel :'impreza'}];

.

כאשר:

בJSON המערך עטוף בסוגריים מרובעים.
כל אלמנט במערך מייצג אובייקט.
שורה 1 - ניתן להגדיר אלמנטים מסוגים פשוטים (מחרוזות, ערכים בוליאנים, ערכים מספרים)
שורה 2 - ניתן להגדיר אלמנטים שהם בעצמם אובייקטים.

דוגמא לעבודה עם אחד המערכים:

if (arrCar[0].sManufacturer == 'toyota')
{
    // do something
}

הגדרה מורכבת

דוגמא זו מראה כיצד ניתן להגדיר אובייקט בתוך אובייקט, מאפיינים מסוג פונקציות ושימוש במערך בתוך אובייקט:

var oUser = {
    sName : 'eran', 
    arrChildren : [],
    oStatus : {bIsHappy : true, bIsFriendly : true},  
    introduce : function() 
    {
        alert(this.sName);
    }
};

כאשר:

כתבתי כל מאפיין בשורה נפרדת. זה נעשה לצורך קריאות בלבד. אפשר לכתוב את הכל בשורה אחת.
המאפיין arrChildren הוא מסוג מערך וכרגע אין לו ערכים.
המאפיין oStatus הוא אובייקט פנימי (מאותחל אוטומטית כפי שראינו בהגדרה הפשוטה).
המאפיין Introduce הוא מסוג פונקציה.

דוגמא לשימוש באובייקט:

// add child to array
oUser.arrChildren.push({sName : 'gali'});

// access inner object
oUser.oStatus.bIsHappy = true;

// execute object function
oUser.introduce();

הגדרת אובייקט ברמת האפליקציה

יש 2 דרכים להגדיר את האובייקט ברמת האפליקציה.

דרך 1 – הגדרה עקיפה (implicit)

כדי ליצור אובייקט ברמת האפליקציה נגדיר משתנה במקום כלשהו בעמוד. יש לוודא שהוא לא מוגדר בתוך פונקציה. במאמר נפרד אתמקד בנושא הscoping של משתנים. בשלב זה מספיק להבין שאם הגדרתם משתנה כלשהו ברמת העמוד, הוא יהיה נגיש בכל מקום בקוד.

var oUser = { sName : 'eran', nAge : 30, bMarried : true };

דרך 2 – הגדרה ישירה (explicit)

בדרך זו נעבוד עם האובייקט window ונוסיף אליו את האובייקט שיצרנו.

window["oUser"] = { sName : 'eran', nAge : 30, bMarried : true };

חשוב לציין ששתי הדרכים מבצעות את אותו הדבר. ההבדל היחידי הוא שבדרך 1 כשמגדירים משתנה ברמת העמוד הוא אוטומטית מתווסף לאובייקט window. בדרך 2 אנחנו מוסיפים אותו בעצמנו לאובייקט window.

סיכום

במאמר זה ראינו דרך נוחה להגדרת אובייקט בשפה javascript. לשיטה זו יתרונות רבים. אני ממליץ בחום לנסות את השיטה רק תזהרו – זה ממכר. בקישור הבא ניתן לראות דוגמא לקוד שנלקח מאתר מוכר ונכתב כמתואר במאמר זה:

קובץ לדוגמא עם קוד JS מחולק נכון (שימוש בכלים שכתובים במאמר זה)

הערות לסיום

האם יש הבדל בין קוד שנכתב בקובץ js חיצוני לקוד שנכתב בתוך העמוד?

מבחינה פונקציונאלית אין הבדל. הדפדפן מייבא את קובץ הjs החיצוני ו"מדביק" את התוכן שלו בתוך העמוד. מכאן שניתן להגדיר אובייקטים בקובץ חיצוני או בתוך העמוד ושניהם יתנהגו באופן זהה. קיים הבדל הקשור לביצועים אבל זה לא רלוונטי למאמר זה.

כיצד לקרוא לפונקציה A מתוך פונקציה B כששתי הפונקציות שייכות לאובייקט

נשתמש במילה השמורה this. אופציה נוספת - היות ומדובר באובייקט שנוצר ברמת האפליקציה ניתן לפנות אליו על-ידי שימוש בשם המלא של האובייקט. הקוד הבא מראה דוגמא לשימוש בשתי האפשרויות:

var oSearch = {
    performSearch : function(sQuery)
    {
        // alternative 1 - using the reserved word 'this'
        this.executeSearch(sQuery,false);
        // alternative 2 - calling the application object 'oSearch' (defined in line 1)
        oSearch.executeSearch(sQuery,false);
    },
    executeSearch : function(sQuery, bIsAjax)
    {
        // handle the execute request
    }    
}

חשוב לדעת – אם תבצעו קריאה לפונקציה באופן ישיר תקבלו שגיאה – יש להשתמש באחת משתי הדרכים הרשומות למעלה.

ערן.

Sending an sms from C# in 3 steps

Eran Sakal — Thu, 22 Jul 2010 18:27:00 GMT

שליחת הודעות SMS מאפליקציה ב-3 שלבים פשוטים

חיי המתכנת קלים מאוד בתקופתנו בהשוואה לחצי עשור אחורה. היום אפשר לבנות אפליקציות שלמות המבוססות על אינטגרציות למערכות ייעודיות, מקצועיות ובוגרות בתחומן. אחד האפליקציות שפיתחתי דרשה יכולת שליחה של הודעות SMS ללקוחות.

ההודעות מיועדות להשלח בארצנו בלבד ולכן חיפשתי פתרונות מקומיים העונים על הדרישות הבסיסיות הבאות:

התממשקות למערכת שליחת הודעות SMS באמצעות webservice.
אפשרות לשליחת הודעה למספר נמענים בו-זמנית וקבלת חיווי על הצלחה/כשלון.
ממשק ניהול נוח ליצירת דוחות מעקב.
זמינות של תמיכה ושירות.

מגיגול שעשיתי איתרתי 3 חברות רלוונטיות:

בחרתי לנסות את “Simple Sms” היות והאתר שלהם מכיל את מלוא האינפורמציה הנדרשת. מדפדוף באתר אפשר לדעת עלויות, פרטים על דרך ההתממשקות, טפסים אלקטרונים לרכישת חבילת הודעות. אז רכשתי חבילת הודעות, הורדתי קוד לדוגמא, הקלדתי את הפרטים הרלוונטים ו… השליחה נכשלה בתואנה שאין לי חבילת הודעות. לימים גיליתי כי הצד החלש שלהם הוא השירות. כשמתקשרים ב-90% מהפעמים מגיעים למוקדנים חיצוניים לחברה וכל מה שאפשר זה להשאיר הודעה ולהמתין. אך היות וכבר רכשתי חבילת הודעות החלטתי לתת להם צ’אנס ולהמשיך בהתממשקות. תמיד אפשר להחליף בקלות בהמשך אם רוצים.

לפני שנמשיך רציתי לציין כי “שמיר מערכות” עשו עלי את הרושם הרציני ביותר עם סל המוצרים עשיר מבין שלושת החברות. ייתכן ובזמן הקרוב אדרש לממשק אפליקציה לשירותי SMS. במידה וזה יקרה אעדכן בפוסט את חווית העבודה מולם.

במאמר זה נראה איך ב-3 שלבים פשוטים ניתן להוסיף יכולות שליחה של הודעות SMS מאפליקציות .net.

שלב 1 – פתיחת חשבון

בשלב זה נקים חשבון בחברה, נרכוש חבילת הודעות SMS, ונפעיל את התמיכה בAPI מצד SimpleSMS.

הרשמה לאתר

הכנסו לאתר החברה וצרו משתמש חדש (פעולה זו לא עולה כסף).
בחרו את חבילת ההודעות המתאימה (מחיר הודעה משתנה בהתאם לחבילה שבוחרים ונע בין 0.29 ל 0.15 אג).
בצעו רכישה דרך האתר של החבילה שבחרתם.

יצירת חשבון לשימוש ב-webservice

בשלב זה צריכים ליצור משתמש נוסף שישמש אותנו להתממשקות לwebservice. לצערי אין אפשרות ליצור את המשתמש הנ”ל דרך האתר וחייבים לעשות זאת בשיחה מול נציג החברה או באמצעות מייל. לא קל לתפוס אותם אז היו סבלנים ואל תתביישו ל"נדנד" מספר פעמים ביום עד שזה יבוצע.

ליצירת המשתמש - צרו קשר טלפוני ו/או בדוא”ל ובקשו:

לפתוח חשבון webservice עבור המשתמש שיצרתם באתר.
להעביר את כל ההודעות שרכשתם מהחשבון באתר לחשבון הwebservice.

הנציג אמור לחזור אליכם עם 2 פרטי משתמשים חדשים בנוסף לזה זה שיצרתם באתר. האחד משמש לשליחת הודעות דרך הwebservice והשני לצורך כניסה למערכת ניהול הwebservice.

שלב 2 – אינטגרציה

אחרי שסיימנו עם הצד של SimpleSMS, הגיע הזמן לחבר בין האפליקציה לשירותי הwebservice. אתם מוזמנים להוריד את “המדריך למשתמש” או “חבילת דוגמאות קוד” מהאתר שלהם ולדלג לשלב 3 – או להמשיך לקרוא הסבר מקוצר.

פתחו פרוייקט חדש/קיים והוסיפו web reference לכתובת הבאה (נלקחה מאתר החברה). בחרתי לקרוא לweb reference בשם “SimpleSmsProxy” אבל אתם רשאים לבחור שם אחר אם תרצו.

השתמשו בקטע קוד הבא לשליחה של הודעת SMS לטלפון סלולארי אחד או יותר

public bool SendSms(string[] toMobile, string message) 
{ 
    SimpleSmsProxy.SendService service = new SimpleSmsProxy.SendService(); 
    bool sendSucceeded = service.SendBulkMessage("{your username}", "{your password}", "{sender mobile}", toMobile, message); 

    return sendSucceeded; 
}

הערה - הקפידו להשתמש בשם המשתמש והסיסמא הנכון.

ריכזתי פה את ארבעת המתודות השכיחות בשירות זה. היה לי חשוב להציג פה גם את המתודות שמבצעות קריאה א-סנכרונית. זה יכול להיות מאוד שימושי במצב של “שגר-ושכח” ורוב הסיכויים שבזה תשתמשו באפליקציה.

public bool SendMessage(string username, string password, string fromMobile, string toMobile, string message)
public void SendMessageAsync(string username, string password, string fromMobile, string toMobile, string message)
public bool SendBulkMessage(string username, string password, string fromMobile, string[] toMobile, string message)
public void SendBulkMessageAsync(string username, string password, string fromMobile, string[] toMobile, string message)

שימו לב! בשלב זה ההודעות עדיין לא יישלחו בפועל לפלאפונים. זאת היות ומשתמש חדש בSimpleSMS מוגדר כברירת מחדל במצב של “בדיקות”. מברוכ למפתחי SimpleSMS על החשיבה הבריאה שנועדה לאפשר ביצוע בדיקות אינטגרציה מבלי לבזבז הודעות מהחבילה. חבל רק שזה לא מתועד באף מקום ועלה לי ביזע רב לגלות זאת. אז איך תדעו שהאינטגרציה עבדה? הכנסו לממשק הניהול הwebservice – בממשק ניתן לראות את ההודעות והסטטוס שלהם (נשלח/לא נשלח/הודעת בדיקה).

שלב 3 – יציאה ממצב בדיקות

כפי שהסברתי בסוף הסעיף הקודם, הודעות שיישלחו מהאפליקציה יגיעו לממשק הניהול בSimpleSMS ולא יישלחו לפלאפון (מצב בדיקות). כדי לצאת ממצב זה יש לבצע את הפעולות הבאות:

הכנסו למערכת ניהול משתמש webservice
בתפריט למעלה בחרו “פרטים אישיים” –> “עדכון פרטי חשבון”
הורידו את הV המסומן בשדה “שליחת נסיון”
וודאו כי הערך של השדה “חשבון דמו” הוא “לא”
שימרו את השינויים.

זה הכל. המערכת אמורה לשלוח הודעות. נסו בעצמכם.

מילות סיכום

במאמר זה ראינו איך ניתן במספר שלבים פשוטים לבצע שליחה של הודעות SMS מאפליקציות .net לטלפונים סלולארים. הדגמתי איך לעשות זאת בעזרת חברת “Simple SMS” אבל אני חייב להודות שלמרות פשטות העבודה מולם הם לא הבחירה המועדפת עלי בגלל חסרונותיה שרשומים למטה. בפרויקט בינוני/גדול אני ממליץ לבחון ראשית את החברות הנוספות ורק אז להחליט מי הכי מתאימה עבורכם. עבור פיתוחים מהירים/בייתים/POC השירות שלהם מספק בהחלט.

יתרונות “Simple SMS”

מתאים לפיתוחים אישיים – תהליך הרישום פשוט ולא דורש שיחות והסברים מול החברה.
מדריך למשתמש פשוט וברור כולל דוגמאות קוד בשפות שונות לצורך התממשקות למערכת ושליחת הודעות.
ממשק ניהול פשוט ונוח המאפשר מעקב אחר משלוח הודעות, רכישת חבילות וכו’.

חסרונות “Simple SMS”

זמינות, זמינות, זמינות – קיים קושי רב ביצירת קשר עם נציג אמיתי (לא מוקדן) לקבלת שירות ו/או תמיכה טכנית.
אבטחה - עושה רושם כי אין להם SSL Certificate. אני רושם זאת בהיסוס קל היות ושלחתי אליהם מייל בנושא ולמרבה ה”הפתעה” עד כה לא קיבלתי תשובה. אז אני נותן להם קרדיט קטן שאולי יש להם והם מצניעים זאת מסיבה לא ברורה :).

כפי שציינתי בתחילת הפוסט, אעלה עדכון קצר בהמשך לאחר שאתממשק ל”שמיר מערכות”.

ערן

Multi-Thread in a nutshell

Eran Sakal — Thu, 15 Jul 2010 19:07:00 GMT

אם אתם מתכנתים אפליקציות web לאינטרנט – אתם נמצאים בסביבה מרובת משתמשים וזה אומר שאתם צריכים לדעת להגן על משאבים משותפים.

היות ונושא פיתוח אפליקציות לסביבות מרובות משתמשים הוא מורכב וגדול, בלתי אפשרי לסכם אותו בפוסט אחד. לכן השתדלתי בפוסט זה להציג את הנושאים שמתאימים ל-90% מהפיתוחים.

טרמינולוגיה

סעיף זה מרכז מושגים שיופיעו בפוסט. אין צורך להתעמק בשלב זה במושגים, לאחר קריאת הפוסט הם יהיו ברורים יותר.

Request = גלישה על-ידי משתמש לעמוד באתר. אם נתייחס לדפדפנים השכיחים המכילים Tabs, כל Tab בדפדפן שגולש לעמוד באתר הינו Request.

Thread = מבלי להכנס לדקויות כל גלישה לעמוד באתר (כל Request) מתבצע בThread משלו. אז ניתן להגיד שכל Request שווה לפחות Thread אחד נפרד.

Resource = משאב באתר. המילה משאב מתייחסת גם לdatabase, קבצי מערכת ועוד. במאמר זה נתמקד במשאבים מסוג משתנים משותפים.

MultiThreaded environment = סביבה מרובת משתמשים (לדוגמא אתרי web שמאפשר גלישה של עשרות עד אלפי משתמשים בשניה).

Thread-Safe = קוד שפותח תוך הקפדה על עקרונות פיתוח בסביבה מרובת משתמשים ומנהל נכון משאבים משותפים.

רגע לפני שמתחילים

multi-threading מתחלק ל-2 נושאים מרכזיים:

פיתוח אפליקציות שיבצעו פעולות בצורה מקבילית (Multi-threaded application).
בהנתן שהאפליקציה שלך מבצעת פעולות בו-זמנית או פועלת בסביבת מרובת משתמשים – ניהול נכון של המשאבים המשותפים.

היות וכל מי שכותב בasp.net כותב בסביבה מרובת משתמשים גם אם הוא לא מודע לכך - בחרתי לכתוב בפוסט זה על הנושא השני. בסוף המאמר צירפתי קישורים למאמרים מפורטים המתייחסים גם לנושא הראשון.

הגדרה של משאב משותף

משאב משותף הינו משאב שניתן להגיע אליו בו-זמנית ממספר threads על-ידי מספר גולשים. דוגמא טובה לזה ניתן למצוא באתר ויקיפדיה. אם תכנסו לקישור הבא תראו מידע על פינגווינים. מידע זה נגיש לכל מי שגולש לעמוד. בחלק העליון של העמוד יש כפתור “עריכה” שמאפשר לגולשים לערוך את המידע. עריכה של המידע תשפיע על כל שאר הגולשים שצופים בעמוד. מידע זה עונה להגדרה של משאב משותף היות והמידע הזה משותף לכל מי שגולש לעמוד. ייתכן שהמידע הזה נשלף מבסיס נתונים ואז בסיס הנתונים הינו המשאב המשותף. ייתכן והמידע נשלף מתוך אובייקט שנמצא בזיכרון של השרת ואז האובייקט הזה הינו משאב משותף.

דוגמאות לאובייקטים שעונים על ההגדרה:

משתנים סטטים (static members).
אובייקטים שנשמרים ברמת Application/Session.
אובייקטים שנשמרים בתשתית Cache כלשהי.

מדוע צריך לנהל גישה למשאב משותף

נסתכל על הדוגמא הבאה. נניח וכתבנו מנגנון שמאפשר לגולשים לקבל קופונים. בדוגמא זו אין מגבלה על כמות הקופונים לחלוקה. כאשר גולש מבקש לקבל קופון יתבצעו 2 פעולות - בדיקה אם נשארו קופונים ואם כן שליחה של הקופון לגולש. נניח מצב שבו 2 גולשים מבקשים קופון בו-זמנית. המחשב יכול לטפל ב-2 הבקשות באחת מהדרכים הבאות (אין לנו שליטה כרגע על בחירת המחשב):

לטפל בגולש א’ ולאחר מכן בגולש ב’
לטפל בגולש ב’ ולאחר מכן בגולש א’
לטפל במקביל ב-2 הגולשים.

התרשים הבא מראה דוגמא למצב שבו המחשב מבצע טיפול במקביל ב-2 הגולשים (לחץ על התרשים להגדלה).

כאשר:

שני הגולשים מבקשים לקבל קופון באותו הזמן.
רצף הפעולות שביצע המחשב: פעולה 1 – בדיקה אם נשאר קופון עבור גולש א’. פעולה 2 – בדיקה אם נשאר קופון עבור גולש ב’. פעולה 3 – שליחת קופון לגולש א’. פעולה 4 – שליחת קופון לגולש ב’.
היות וכמות הקופונים לא מוגבלת אין צורך בפעולה כלשהי של כתיבה ואין חשש למצב שבו יתקבלו נתונים שגויים.

נמשיך לדוגמא נוספת. בדוגמא זו כמות הקופונים מוגבלת. מכאן שבמידה וגולש כלשהו מקבל קופון, יורד המספר הכללי של הקופונים האפשרים לחלוקה באתר. לצורך כך נבצע בדיקה אם נשארו קופונים. במידה ונשארו נפחית את מספר הקופונים באחד ונשלח את הקופון לגולש. מה הבעיה שיכולה לקרות? נניח בדוגמא זו שנשאר רק קופון אחד לחלוקה. ראינו למעלה כי אין לנו שליטה על סדר הפעולות שיבצע המחשב ולכן שוב ייתכן מצב שבו המחשב יטפל ב-2 הגולשים כפי שניתן לראות בתרשים (לחץ על התרשים להגדלה).

כאשר:

שני הגולשים מבקשים לקבל קופון באותו הזמן.
רצף הפעולות שביצע המחשב: פעולה 1 – בדיקה אם נשאר קופון עבור גולש א’. מחזיר תשובה חיובית (נשאר קופון 1). פעולה 2 – בדיקה אם נשאר קופון עבור גולש ב’. מחזיר תשובה חיובית (כרגע מבחינת המחשב עדיין נשאר קופון 1). פעולה 3 – הורדת מספר הקופונים באחד (הקופון שיישלח לגולש א’) - נשאר במערכת 0 קופונים. פעולה 4 – הורדת מספר הקופונים באחד (הקופון שיישלח לגולש ב’). שלב זה שגוי שכן אין יותר קופונים! אבל היות והבדיקה נעשתה לפני ההחסרה של מספר הקופונים עבור גולש א’ מספר הקופונים יהיה 1-. פעולות 5 ו-6 – שליחת קופונים לגולש א’ וגולש ב’. יוצא שחילקנו קופון שלא קיים לגולש ב’.
קיבלנו מצב שגוי והפסדנו קופון ששלחנו לגולש ב’ למרות שלא נשארו יותר קופונים.

מה היה קורה אם 200 איש היו מבקשים בו זמנית את הקופון? לפי הדוגמא למעלה ניתן לראות כי במצב תיתכן חלוקה של עד 199 קופונים יותר מהמתוכנן.

מה הפתרון למצב זה? כדי לפתור מצב זה צריך להתייחס לשלושת השלבים (הבדיקה, החסרת מספר הקופונים ושליחת הקופון) כפעולה אחת. צריך להורות למחשב לטפל כל פעם בגולש אחד בלבד. בדוגמא למעלה אם הפעולות היו מבוצעות ברצף לכל גולש אז גולש א’ היה מקבל את הקופון וגולש ב’ היה מקבל הודעה שלא נשארו יותר קופונים. בפוסט זה נלמד כיצד ניתן להורות למחשב לגרום לגולש ב’ להמתין עד שגולש א’ יסיים להריץ את כל שלושת הפעולות. התרשים הבא מראה כיצד זה יבוצע (לחץ על התרשים להגדלה).

דרכים לניהול משאבים משותפים (כתיבת קוד Thread-Safe)

בסעיפים למעלה ראינו שחשוב לנהל בצורה מבוקרת גישה למשאב משותף כדי להמנע ממצבים לא מתוכננים. בסעיפים הבאים נראה כיצד מבצעים זאת בשפה #C.

קוד שמוגדר כThread-Safe הינו קוד שהמתכנת לקח בחשבון מצבים של קריאה-כתיבה בו זמנית למשאבים שהוא משתמש בהם. בסעיף זה נראה מספר תרחישים ואת הכלים העומדים לרשותנו לפתרון התרחיש.

תרחיש ראשון – קריאה-כתיבה בו זמנית (הכי שכיח)

תרחיש זה פותר את בעיית הקופונים שכתבתי למעלה. בתרחיש זה יש לנו מספר פעולות שאנחנו רוצים שיקרו ברצף ושלא תהיה אפשרות ל-2 גולשים לבצע במקביל את הפעולה. כדי לעשות זאת נשתמש במנגנון מסוג lock.

נסתכל על הקוד הבא (כרגע לא מטפל בסוגיית הThread-Safe):

private int m_couponsLeft;

public string GetCoupon()
{
    if (m_couponsLeft > 0)
    {
        m_couponsLeft--;
        return "193445023"; // Dummy Coupon Number
    }
    else
    {
        return string.Empty;
    }
}

private bool HasMoreCoupons()
{
    return (m_couponsLeft > 0);
}

כאשר:

המשאב המשותף במקרה הזה הוא המשתנה “m_couponsLeft”.
שורה 3 – מגדירה מתודה שמחזירה קופונים במידה ונשארו (מתודה זו מבצעת קריאה וכתיבה למשאב המשותף).
שורה 5 – בודקת אם נשארו קופונים מול המשאב המשותף (המשתנה m_couponsLeft).
שורה 7 – מחסירה באחד את מספר הקופונים שנשארו.
שורה 8 – נקראת במידה ונשארו קופונים. מחזירה את מספר הקופון.
שורה 12 – נקראת במידה ולא נשארו קופונים – מחזירה ערך ריק.
שורה 16 – מגדירה מתודה שמבצעת בדיקה בלבד אם נשארו קופונים (מתודה זו מבצעת קריאה בלבד מהמשאב המשותף).

מה יקרה אם 2 גולשים שונים יקראו בו-זמנית למתודה “GetCoupon” כאשר מספר הקופונים הנותרים הוא 1? אם התשובה לא קופצת לך מיד בראש – קרא שוב את הסעיף “מדוע צריך לנהל משאב משותף”.

כדי לפתור את הבעיה נבצע שינוי קטן של המתודה “GetCoupon”. נסתכל על הקוד הבא:

private int m_couponsLeft;
private object m_couponLockObj = new object();

public string GetCoupon()
{
    lock (m_couponLockObj)
    {
        if (m_couponsLeft > 0)
        {
            m_couponsLeft--;
            return "193445023"; // Dummy Coupon Number
        }
        else
        {
            return string.Empty;
        }           
    }        
}

private bool HasMoreCoupons()
{
    lock (m_couponLockObj)
    {
        return (m_couponsLeft > 0);   
    }        
}

כאשר:

שורה 2 – מגדירה אובייקט שכל מטרתו לנהל את הגישה למשאב המשותף
שורות 6 ו22 – שורות אלו מבצעות את הנעילה בפועל. הפקודה lock מתבצעת על האובייקט שהוגדר בשורה 2 ומתבצעת לפני פניה למשאב המשותף (m_couponsLeft).

פרוש הפקודה lock היא : בדוק אם האובייקט שהועבר אליך נעול על-ידי משתמש אחר, אם לא - נעל אותו והמשך הלאה. אם הוא נעול על-ידי משתמש אחר - המתן עד שהוא ישתחרר ואז נעל אותו והמשך הלאה. קיבלנו פה מנגנון שמאפשר “בלעדיות” על אובייקט.

איך זה משרת את הצורך? עכשיו ניתן לדעת בוודאות שהפעולות יתבצעו לפי סדר הקריאה. אם בוצעה קריאה בו זמנית למתודה, הגולש שקרא לה ראשון ישיג את ה”בלעדיות” ויקבל את הקופון. הגולש השני ימתין עד שתשתחרר הנעילה ורק אז יבצע את הבדיקה ובמקרה שלנו יקבל הודעה שלא נשארו קופונים.

מספר דגשים חשובים:

את הנעילה מבצעים על אובייקט מסוג reference-type כאשר מומלץ שזה לא יהיה האובייקט שאותו מנהלים. ספציפית בדוגמה שנתתי פה לא יכולתי לנעול את המשאב עצמו היות והוא מסוג value-type אבל גם אם כן לא הייתי מבצע עליו נעילה.
מיד אחרי הפקודה lock מגדירים סוגריים מסולסלים. זהו הScope של הנעילה. ברגע שיוצאים מהתיחום של הסוגריים (שורה 17) הנעילה משתחררת אוטומטית. השיחרור האוטומי יקרה גם במצב של Exception שנזרק בתוך הסוגריים או במצב של return (מצב נוכחי).
יש הרבה דוגמאות קוד באינטרנט שמראות שימוש בlock על האובייקט this במקום על אובייקט אחר, לצורך העניין שורה 6 תכיל את הקוד lock(this);. מצב זה לא תקין, יכול להוביל לdead-lock ולכן יש להמנע מלהשתמש בו. ניתן לגגל על נושא זה.

תרחיש שני – קריאה מרובה למשאב וכתיבה מועטה לאותו המשאב

המנגנון הבא הינו אופטימיזציה של מנגנון ה-lock שראינו בסעיף הקודם. נשתמש באותה דוגמא מהסעיף הקודם אבל נוסיף מידע נוסף. נניח וידוע לנו שתדירות הקריאה למתודה “HasMoreCoupons” גדולה בהרבה מתדירות הקריאה למתודה “GetCoupon”. במצב כזה שימוש בlock פוגם לנו בביצועים. מדוע?

הפגיעה בביצועים נגרמת היות והמנגנון lock הוא טורי, רק אחד רשאי לבצע בכל פעם את הקוד שבתוך הlock. נסתכל על המתודה “HasMoreCoupons”. במתודה זו אנחנו מבצעים קריאה בלבד מהמשאב (אין כתיבה למשאב במתודה). אם יש מאתיים פעולות קריאה למתודה הן יתבצעו אחת אחרי השניה. אבל מהסעיפים הקודמים למדנו שאין בעיה של Thread-Safe במצב של קריאה בו-זמנית. הבעיה היא רק במצב של כתיבה בו-זמנית או קריאה וכתיבה בו זמנית.

על-מנת לתמוך בתרחיש זה נשתמש ברכיב שנקרא ReaderWriterLockSlim. נסתכל על הקוד הבא:

private int m_couponsLeft;
private ReaderWriterLockSlim m_couponLockObj = new ReaderWriterLockSlim();

public string GetCoupon()
{
    try
    {
        m_listLocker.EnterWriteLock();

        if (m_couponsLeft > 0)
        {
            m_couponsLeft--;
            return "193445023"; // Dummy Coupon Number
        }
        else
        {
            return string.Empty;
        }    
    }
    finally
    {
        m_listLocker.ExitWriteLock();
    }        
}

private bool HasMoreCoupons()
{
    try
    {
        m_listLocker.EnterReadLock();

        return (m_couponsLeft > 0);   
    }
    finally
    {
        m_listLocker.ExitReadLock();
    }     
}

כאשר:

קיבלנו הפרדה בקוד בין מצבים בהם מבצעים רק קריאה למשאב לבין מצבים בהם מבצעים גם כתיבה למשאב.
שורה 2 – מגדירה אובייקט מסוג “ReaderWriterLockSlim” באמצעותו ננהל את הגישה למשאב המשותף.
שורה 8 – מודיעה לאובייקט כי הקוד הבא מבצע כתיבה למשאב.
שורה 22 – מודיעה לאובייקט כי הקוד סיים לבצע את הכתיבה למשאב.
שורה 30– מודיעה לאובייקט כי הקוד הבא מבצע קריאה למשאב
שורה 36– מודיעה לאובייקט כי הקוד סיים לבצע את הקריאה למשאב.

איך זה משרת את הצורך? המנגנון ReaderWriterLockSlim מאפשר טיפול במקביל (בו-זמנית) בפעולות שננעלו לקריאה (שורה 30) כל עוד לא בוצעה בקשה לנעילה של כתיבה למשאב. ברגע שתורץ שורה 8 (בקשת “בלעדיות” לכתיבה למשאב), לא יתאפשר יותר נעילות לצורך קריאה (שורה 30). בקשות אלו יתווספו לתור המתנה. לאחר סיום טיפול בכל נעילות הקריאה שהתחילו לפני הבקשה לנעילת כתיבה , תתבצעה פעולת הכתיבה. לאחר סיום פעולת הכתיבה יבוצעו כל הבקשות לקריאה שנשמרו בתור ההמתנה.

מספר דגשים חשובים:

בתרחיש שבו מרבית הפעולות על המשאב הינן פעולות קריאה קיבלנו אופטימיזציה מעולה מבחינת ביצועים שכן פעולות קריאה יבוצעו בצורה מקבילית.
שימו לב לסיומת של שם המחלקה – ReaderWriterLockSlim (קיים אובייקט עם שם זהה בלי הסיומת Slim).
חובה להשתמש ב - try…finally ולוודא שכותבים את השחרור של הנעילה בfinally. אחרת מספיק Exception אחד כדי ליצור מצב מצב של dead-lock.

תרחיש שלישי – פעולות על משתנה בודד

בדוגמאות הקודמות ראינו כיצד לבצע נעילה על מספר שורות קוד. מה בנוגע למצבים בהם מתבצעת פעולה על משתנה בודד (שורת קוד אחת)? האם עדיין צריך לנהל אותו כמשאב משותף?

נבחן את הדוגמא הבאה. יש לנו משתנה מסוג int שסופר כניסות לאתר. האם הפעולה הבאה לדעתך היא Thread-Safe?

requestCounter++;

למרבה ההפתעה התשובה לכך היא לא. זאת היות והשורה הנ”ל מתורגמת על-ידי המחשב ל-3 פקודות מכונה. הסבר טוב לכך נמצא בפוסט הבא. כדי להתגבר על הבעיה ניתן אומנם להשתמש בשיטות שלמדנו למעלה אבל זה אומר שנצטרך לרשום הרבה שורות קוד רק כדי להגן על פעולה פשוטה יחסית של העלאת ערך משתנה ב-1 (שורה אחת).

כדי לפשט את העניין קיים האובייקט “Interlocked” שיושב תחת הnamespace הבא - “System.Threading”. בעזרתו ניתן לכתוב את השורה למעלה בצורה הבאה:

Interlocked.Increment(ref requestCounter);

אני לא אכנס להסבר על אובייקט זה היות והתיעוד שלו בMSDN פשוט וברור.

תרחיש רביעי (ואחרון) – איתחול משאב משותף

נניח ויש לנו משתנה שאותו אנחנו צריכים לאתחל. מה יקרה אם מספר גולשים בו זמנית יאתחלו את האובייקט?

נסתכל על הקוד הבא:

private DataManager m_manager = null;

public DataManager GetManager()
{
    if (m_manager == null)
    {
        m_manager = new DataManager();
    }

    return m_manager;
}

כאשר:

שורה 3 – מגדירה מתודה שאחראית להחזיר אובייקט מסוג DataManager (משאב משותף).
שורה 5 – בודקת אם האובייקט כבר מאותחל.
שורה 7 – במידה והאובייקט לא אותחל עדיין שורה זו נקראת ומאתחלת אותו.
שורה 10 – מחזירה את האובייקט מסוג DataManger.

אני מניח שבשלב זה כבר ברורה הבעיה בקוד זה. כדי לפתור את הבעיה נשתמש ב“Design Pattern” מסוג Singleton. מדובר בתבנית שמדגימה איך צריך לאתחל משאב משותף בסביבה מרובת משתמשים. אני מצרף קישור למאמר באינטרנט שנותן הסבר טוב לנושא. בנוסף ניתן למצוא בקלות הסברים נוספים בעזרתו האדיבה של גוגל.

private DataManager m_manager = null;
private object m_managerLock = new object();

public DataManager GetManager()
{
    if (m_manager == null)
    {
        lock (m_managerLock)
        {
            if (m_manager == null)
            {
                m_manager = new DataManager();
            }
        }
    }

    return m_manager;
}

כאשר:

שורה 4 – מגדירה מתודה שאחראית להחזיר אובייקט מסוג DataManager (משאב משותף).
שורה 6 – בודקת אם האובייקט כבר מאותחל.
שורה 8 – במידה והאובייקט לא אותחל עדיין שורה זו נקראת ומבקשת “בלעדיות” לצורך איתחול המשאב.
שורה 10 – לאחר קבלת הבלעדיות מבצעים בדיקה נוספת לוודא שעדיין לא אותחל האובייקט.

מתי צריך לנהל גישה למשאב משותף

סעיף זה מרכז רשימה של מקרים בהם נצטרך לנהל גישה למשאב משותף.

צריך לנהל גישה כאשר:

עובדים בסביבה מרובת משתמשים (לדוגמא אתר באינטרנט) ויש מצב ששני Threads יקראו לאותו המשאב.
מעורבת פעולה של כתיבה למשאב המשותף.

לא צריך לנהל גישה כאשר:

מבצעים רק פעולות של קריאה מהמשאב המשותף
כאשר מבצעים קריאה למתודה (מתודה לא נחשבת כמשאב משותף - יוסבר בהמשך סעיף זה)
כאשר מבצעים קריאה למשתנים שהscope שלהם הוא מתודה (יוסבר בהמשך סעיף זה).

האם צריך לנהל מצב שבו קוראים למתודה

תשובה מהירה – לא! מבלי להכנס לפרטים טכנים, כשקוראים למתודה מבצעים קריאה למקום כלשהו בזיכרון שמכיל את הפקודות שמרכיבות את המתודה. היות ולא מעורבת פעולה של כתיבה אין צורך להגן על קריאה למתודה.

האם משתנים שהscope שלהם הוא מתודה דורשים הגנה

תשובה מהירה – לא! שוב מבלי להכנס לפרטים טכנים, עבור כל מתודה שמורצת מוקצה איזור בזיכרון. באיזור זה נשמרים כל המשתנים ששייכים למתודה. המתודה הבאה מכילה 2 משתנים (rand ו-result). אם לדוגמא 2 גולשים יקראו למתודה הבאה בו-זמנית,לא תהיה בעיה מבחינת MultiThread היות ולכל מתודה יוקצה מקום משלו בזיכרון ויאותחל עבורו המשתנים בנפרד.

public int doSomething()
{
    Random rand = new Random();
    int result = rand.Next();
    return result;
}

כיצד ניתן לדעת אם מתודה מסויימת היא Thread-Safe

בסעיף הקודם ראינו שקריאה למתודה לא דורשת הגנה של Multi-Thread. אם כך מדוע צריך לבדוק אם מתודה היא Thread-Safe? התשובה לכך היא שכאשר מציינים שמתודה היא Thread-Safe מתכוונים שהיא תוכנתה על-בסיס עקרונות של סביבת מרובת משתמשים והיא מנהלת משאבים משותפים בצורה שהיא Thread-Safe.

כדי לדעת אם מתודה היא Thread-Safe צריך לפנות לתיעוד של המחלקה הרלוונטית. לצורך דוגמה נסתכל על המתודה Add של המחלקה הגנרית “System.Collections.Generic.List”. כדי לדעת שהמתודה Add של המחלקה List היא לא Thread-Safe נכנסים לקישור הבא בMSDN.

התצלום הבא נלקח מMSDN. בקישור קיים סעיף שנקרא Thread Safety. סעיף זה מופיע לרוב לקראת סוף התיעוד של כל מחלקה שמכבדת את עצמה (או את מתכנתיה).

הדגשתי בקו אדום את המשפט שאומר שכל קריאה לmember (ומכאן גם למתודות) של מופע (Instance) של המחלקה לא מוגן בהקשר של thread-safe.

לסיכום

בפוסט זה רשמתי את העקרונות הבסיסיים אך חשובים עד מאוד של פיתוח בסביבה מרובת משתמשים. אני ממליץ בחום לגגל על נושא זה באינטרנט. תרגישו חופשי לשלוח שאלות אלי או לכתוב שאלות בפורום בתפוז, המורכב מקהילה של מפתחים עם ידע נרחב ונכונות רבה לעזור.

ערן.

קישורים חיצוניים

Threading in C# – מאמרים מעשיים
- לחץ לקריאה (אנגלית) – מאמר מעשי ומקיף. מאמר זה מכיל בנוסף מידע על כלים שאפשרים פיתוח אפליקציות שיעבדו בצורה מקבילית – מומלץ.
- לחץ לקריאה (אנגלית) – מאמר מעשי ומקיף.
Interlocked
- לחץ לקריאה (אנגלית) – תיעוד בMSDN
- לחץ לקריאה (אנגלית) – פוסט קצר ומקצועי המרחיב על נחיצות הinterlocked.
Singleton
- לחץ לקריאה (אנגלית) – דוגמא נוספת