ASP.NET.4GuysFromRolla.com: Why I Don't Use DataSets in My ASP.NET Applications

When you think ASP, think...
All Articles
ASP.NET Articles
ASPFAQs.com
Message Board
Related Web Technologies
User Tips!
Coding Tips
Search

Sections:
Book Reviews
•Sample Chapters
Commonly Asked Message Board Questions
Headlines from ASPWire.com
JavaScript Tutorials
MSDN Communities Hub
Official Docs
Security
Stump the SQL Guru!
Web Hosts
XML
Information:
Advertise
Feedback
Author an Article

Developer
Downloads
International
Internet Lists
Internet News
Internet Resources
IT
Linux/Open Source
Personal Technology
Small Business
Windows Technology
xSP Resources

Search internet.com
Advertise
Corporate Info
Newsletters
Tech Jobs
E-mail Offers
ASP ASP FAQs Message Board Feedback
Print this Page!
Why I Don't Use DataSets in My ASP.NET Applications
By Scott Mitchell

Introduction
A couple weeks ago (April 19th) I gave a talk to the local San Diego ASP.NET SIG and during my talk I mentioned how I, personally, rarely, if ever, use DataSets in my ASP.NET applications, sticking with the good ol' DataReader instead. Since then I have received a number of emails from attendees asking me why I don't use DataSets. Rather than responding to each questioner individually, I decided to write this article explaining my rationale. Read on to learn why I am a DataReader man all the way.

The Fundamentals of the DataReader
Before I can explain why I choose to use DataReaders over DataSets in my Web applications, it's imperative that we all have an understanding of the fundamentals of both DataSets and DataReaders. These two objects have different roles: DataSets are designed to be a mini-in-memory database whereas a DataReader is designed to be a ferry of data between the database layer and a .NET application.

In ADO.NET a provider is some source of data, and there exist provider-specific classes for working with particular providers. There's the SqlConnection, SqlCommand, SqlDataAdapter, and SqlDataReader classes for working with the SqlClient provider; there's the OleDbConnection, OleDbCommand, OleDbDataAdapter, and OleDbDataReader classes for working with the OleDb provider. Objects that are prefixed by a provider name (Sql, OleDb, Oracle, Odbc, etc.) are provider-specific objects. They are designed to work with the particular provider. A DataReader is one such object (i.e., SqlDataReader, OleDbDataReader, etc.).

To work with data via a DataReader you must first establish a connection to the data store and specify the query to execute. Next, the DataReader is created and acts as a bridge between the .NET application and the data store. For example, you might use code like the following:

' Establish Connection
Dim myConnection as New SqlConnection(connection string)
myConnection.Open()

' Create command
Dim myCommand as New SqlCommand(myConnection, SQL query or stored procedure)

' Create a DataReader to ferry information back from the database
Dim myReader as SqlDataReader
myReader = myCommand.ExecuteReader()

'Iterate through the results
While myReader.Read()
  '... Work with the current record ...
End While

' Close the connection (will automatically close the reader)
myConnection.Close()

The DataReader loads one record from the data store at a time. Each time the DataReader's Read() method is called, the DataReader discards the current record, goes back to the database, and fetches the next record in the resultset. The Read() method returns True if a row was loaded from the database, and False if there are no more rows.

DataReaders are connected data objects because they require an active connection to the database. Remember, the DataReader is just a ferry of data between the application and database. Understandably, it cannot ferry information back from the database after the connection has been severed. Furthermore, a DataReader is limited to being read-only and forward-only. That is, the information retrieved from the database cannot be modified by the DataReader, nor can the DataReader retrieve records in a random order. Instead, a DataReader is limited to accessing the records in sequential order, from the first one to the last one, one record at a time.

- continued -

The Fundamentals of the DataSet
DataSets are a more complex and feature-rich object than DataReaders. Whereas DataReaders simply scuttle data back from a data store, DataSets can be thought of as in-memory databases. Just like a database is comprised of a set of tables, a DataSet is made up of a collection of DataTable objects. Whereas a database can have relationships among its tables, along with various data integrity constraints on the fields of the tables, so too can a DataSet have relationships among its DataTables and constraints on its DataTables' fields.

Unlike the DataReader, a DataSet is a provider-neutral data object. There's no SqlDataSet or OleDbDataSet - just a plain, ol' DataSet. It's the responsibility of the provider's DataAdpater object to translate a particular provider's data into the provider-neutral DataSet. The following code snippet illustrates how to populate a DataSet with data from a SQL query.

' Establish Connection
Dim myConnection as New SqlConnection(connection string)
myConnection.Open()

' Create command
Dim myCommand as New SqlCommand(SQL query or stored procedure, myConnection)

' Create the DataAdapter
Dim myDataAdapter as New SqlDataAdapter(myCommand)

' Create the DataSet
Dim myDataSet as New DataSet

' Fill the DataSet
myDataAdapter.Fill(myDataSet)

' Close the connection
myConnection.Close()

'... Work with the contents of the DataSet ...

As the code snippet shows, the DataAdapter's Fill() method populates the DataSet with the results of the specified query. Behind the scenes, the DataAdapter is using a DataReader to read in the results of the query and fill the DataSet. The DataSet is a disconnected data object. Once the DataSet has been filled, the connection can be closed and the DataSet's contents can still be examined and manipulated.

Since a DataSet represents a separate, disconnected collection of data, it's no surprise that the DataSet's data is both editable and can be accessed randomly, two traits not exhibited by the DataReader. Additionally, the DataSet has some powerful XML-related capabilities. For example, you can serialize a DataSet into XML through its WriteXml() method; conversely, you can populate a DataSet from a properly formatted XML stream using the DataSet's ReadXml() method.

The Tradeoff Between the DataSet and DataReader
Regardless of whether or not you bring back database data using a DataSet or DataReader, you can display the underlying data in a DataGrid, DataList, or Repeater using the exact same code. Namely, you set the data Web control's DataSource property to the DataReader or DataSet and then call the Web control's DataBind() method. ASP.NET makes working with data so easy that ASP.NET developers might not give pause and think about what is the best data object to use. All things being equal, it doesn't really matter which data object you use.

But not all things are equal. Clearly there is a major difference in features supported between the DataReader and DataSet, so it's only logical that there be an inverse in the tradeoff between the two objects' performance. Simply put, the DataSet's increased feature set makes it a less performant choice for reading data than the DataReader.

According to A Speed Freak's Guide to Retrieving Data in ADO.NET, the DataReader is roughly thirty times more performant than the DataSet. For large amounts of data being brought back - several hundred or several thousand records - the absolute time differences between accessing data with these two objects can be quite pronounced. The graph below, for example, plots the results from A Speed Freak's Guide to Retrieving Data in ADO.NET for 100 to 1,000 retrieved records using a DataSet (the pink line) and a DataReader (the dark blue line). As the data shows, for retrieving 1,000 records the DataSet is more than 30 times slower than the DataReader (8.89 seconds vs. 0.29 seconds). Eep.

Be sure to read A Speed Freak's Guide to Retrieving Data in ADO.NET for the actual numbers for test runs between 1 to 100 records, 100 to 1,000 records, and 1,000 to 10,000 records, along with the test conditions used. In addition to examining the differences between the DataSet and DataReader, the article compares the performance of the SqlClient provider vs. the OleDb provider when accessing data from a SQL Server 2000 database.

Additional statistics can be found at Performance Comparison: Data Access Techniques, which compares the DataSet and DataReader against a number of common data access scenarios. The end result is that the DataReader is more performant than the DataSet, although this particular article's results do not show as large a performance difference between these two data objects as the Speed Freak article does. Also, the article notes:

In all of the preceding tests, we saw that DataReader outperformed DataSet. As mentioned earlier, the DataReader offers better performance because it avoids the performance and memory overhead associated with the creation of the DataSet. ... The DataReader is a better choice for applications that require optimized read-only and forward-only data access. The sooner you load the data off the DataReader, close the DataReader, and close the database connection, the better performance you get.

When is a DataSet Useful?
Despite the DataSet's performance limitations, there is a time and a place for the DataSet, otherwise it wouldn't be a core component in the .NET Framework. However, it is my contention that rarely, if ever, is the time and place for a DataSet in a Web application. In my experience, DataSets are useful in one of the two following situations:

  1. In a desktop, WinForms application. Consider a desktop-based data entry-type program. A user might fire up the program, load up the sales data from some database server, make some changes, and then want to save those changes. This is an ideal situation for the DataSet. It allows the data to be read into a DataSet residing in the client's memory, which affords the user the ability to work on the data without needing to constantly make trips back to the database. Upon completing editing the data, they can do a batch update, gracefully handling any changes that may have occurred while the user was working with the data in a disconnected state. Furthermore, since the DataSet is a disconnected data store, this data can be taken offline. A salesman traveling to a client's site could load this data and be able to review the data on his laptop while in transit, or while at the client's office.

    (A situation like this might arise in a Web application. I've worked on projects before where the client was adamant that they be able to interact with the Web application as discussed above. That is, they'd be able to visit a page, make a series of changes, and then click a single "Update" button. The underlying database data wouldn't be updated until that "Update" button was clicked. For this particular problem I used a Session-based DataSet, using the same techniques for a DataSet used in a desktop application for batch editing and updating.)

  2. For sending/receiving remote database information or for allowing communication between disparate platforms. Since a DataSet can be serialized/deserialized into XML so easily, they are a prime candidate for sending information across physical boundaries or as a means of serializing data into a platform-neutral format. For example, if you want to return database data from a Web service, one option is to simply read the database data into a DataSet and then return the DataSet from the Web service method. The DataSet will automatically be serialized into XML and sent over the wire. (Personally I don't recommend returning data from a Web service in this manner. Rather, I prefer to use custom business objects - it allows a finer degree of control over the XML serialization, provides a much lighter return payload, and appears less architecture-specific.)
Now, how often are you doing either of these things in your day-to-day ASP.NET development? Hardly ever, I'd wager, which is why you probably shouldn't be using DataSets! While the ASP.NET data Web controls are rather indifferent on what data object you use, you are suffering from a performance loss by choosing to use a DataSet.

Reasons Why You May Be Using a DataSet... and Reasons Why You Probably Shouldn't
In this article I have made a pretty blanket statement in saying, "Use DataReaders in Web applications and don't use DataSets." There are some scenarios in Web applications where it may seem like a DataSet is the only option. For example, imagine that you want to cache some database information that will be used on many pages across the site. This data may be user-specific and stored in the Session, or it may be the same across all users and therefore stored in the data cache. Regardless, a DataReader can't be cached because it is a connected data object, and connections to a database should be short-lived. That is, the absolutely last thing we want is an open connection sitting around in the cache. Therefore, if you want to have cached database data it may seem that the only option is to use a DataSet.

But it isn't the only option. You could, instead, create a class that has as its properties the database fields that you are storing in the DataSet. Then, when you wanted to cache the data, you could use a DataReader to read the query from the database and iterate through the records returned. For each record you'd create an instance of the custom class, set its properties to the field values of the query, and add the custom class to an ArrayList (or, preferably, a strongly-typed collection object). You'd then cache this collection of custom objects. Not only does this method prove more efficient, but, personally, I think it's more maintainable, as it removes the tight coupling between the database field names and accessing their values from the cached object (as with the DataSet). Furthermore, you can bind this custom collection to an ASP.NET data Web control exactly like you would a DataSet or DataReader. (See Displaying Custom Classes in a DataGrid for more information on this technique.)

Another reason you might use a DataSet is because you want to have random access to some data in order to search through the records, because these records may be used repeatedly. For example, when displaying a master/detail DataGrid where one column of a DataGrid contains the parent record and the other column contains another DataGrid with that particular row's children, it might make sense to use a DataSet to grab all of the children records from the database rather than having to requery the database for each DataGrid row's related set of children. (See An Extensive Examination of the DataGrid Web Control: Part 14 for more information on this technique. Essentially, it involves creating a DataGrid that looks similar to the one shown to the right.) The performance tradeoff here depends on how many rows are in the parent table. Since a DataSet is, roughly, 30 times slower than a DataReader, if there are more than 30 records in the parent table being displayed it probably makes sense to use a single DataSet rather than requerying for each parent record. (Ideally, a collection of custom objects would be used, as discussed earlier.)

Conclusion
In this article we examined the fundamentals of the two data access objects provided by ADO.NET: the DataReader and the DataSet. Both objects have their time and place in .NET applications but, in my opinion, DataSets are rarely, if ever, useful in ASP.NET Web applications. There are exceptions, granted, but for the majority of Web applications, DataReaders should be used exclusively.

For a discussion on DataReaders vs. DataSets, be sure to read this article's accompanying blog entry at http://scottonwriting.net/sowblog/posts/3615.aspx. A follow-up article has been posted as well: More On Why I Don't Use DataSets in My ASP.NET Applications.

Happy Programming!

  • By Scott Mitchell

    Windows Internet Technology | ASP Articles | ASPMessageboard.com | ASPFAQs.com | ASP.NET | Advertise | Feedback | Awards | Author an Article

    • JupiterWeb networks:

    Search JupiterWeb:

    Jupitermedia Corporation has three divisions:
    JupiterImages, JupiterWeb and JupiterResearch

    Copyright 2005 Jupitermedia Corporation All Rights Reserved.
    Legal Notices, Licensing, Reprints, & Permissions, Privacy Policy.

    Jupitermedia Corporate Info | Newsletters | Tech Jobs | Shopping | E-mail Offers


ASP.NET.4GuysFromRolla.com: Bubbling Events Up the Control Hierarchy

When you think ASP, think...
All Articles
ASP.NET Articles
ASPFAQs.com
Message Board
Related Web Technologies
User Tips!
Coding Tips
Search

Sections:
Book Reviews
•Sample Chapters
Commonly Asked Message Board Questions
Headlines from ASPWire.com
JavaScript Tutorials
MSDN Communities Hub
Official Docs
Security
Stump the SQL Guru!
Web Hosts
XML
Information:
Advertise
Feedback
Author an Article

Developer
Downloads
International
Internet Lists
Internet News
Internet Resources
IT
Linux/Open Source
Personal Technology
Small Business
Windows Technology
xSP Resources

Search internet.com
Advertise
Corporate Info
Newsletters
Tech Jobs
E-mail Offers
ASP ASP FAQs Message Board Feedback
Print this Page!
Bubbling Events Up the Control Hierarchy
By Scott Mitchell

Introduction
The DataGrid control, as you likely know, can easily be configured to add a column of buttons. By adding a ButtonColumn, whenever one of the DataGrid's buttons in the column is clicked, the Web page posts back and the DataGrid's ItemCommand event fires. In fact, the same behavior can be noted if you manually add a Button or LinkButton control into a DataGrid TemplateColumn, as the ButtonColumn class simply adds a Button (or LinkButton) Web control to each row of the DataGrid.

When the Button (or LinkButton) is clicked, its Command event is raised. But how does the DataGrid know when this event has been raised so that it can raise its ItemCommand event in response? The answer is through a process referred to as event bubbling. Event bubbling is the process of moving an event up the control hierarchy, from a control low in the hierarchy - such as a Button within the row of a DataGrid - and percolating it up to an ancestor control - such as the DataGrid. Once the ancestor control has learned of the event it can respond however it sees fit; in the DataGrid's case, the DataGrid "swallows" the Button's Command event (that is, it stops the bubbling) and raises its own ItemCommand event in response.

In this article we'll look at how, precisely, event bubbling works in ASP.NET. Event bubbling is a technique that all server control developers should be aware of. Additionally, it can be used as a means to pass event information from a User Control to its parent page, as discussed in Handle Events from Web User Controls (although personally I find it simpler to just use the technique of having the User Control raise its own events through the standard event firing syntax as discussed at An Extensive Examination of User Controls). Read on to learn more!

- continued -

Understanding the Control Hierarchy
All ASP.NET pages are represented in code as a hierarchy of controls. While ASP.NET page developers are accustomed to working in terms of the Visual Studio .NET designer and HTML and Web control syntax, this markup is automatically converted into a programmatically-created control hierarchy when an ASP.NET page is first visited (or first visited after a change to its .aspx page's content). To better understand this process, let me refer to a previous article of mine, Understanding ASP.NET View State:

All ASP.NET server controls can have a parent control, along with a variable number of child controls. The System.Web.UI.Page class is derived from the base control class (System.Web.UI.Control), and therefore also can have a set of child controls. The top-level controls declared in an ASP.NET Web page's HTML portion are the direct children of the autogenerated Page class. Web controls can also be nested inside one another. For example, most ASP.NET Web pages contain a single server-side Web Form, with multiple Web controls inside the Web Form. The Web Form is an HTML control (System.Web.UI.HtmlControls.HtmlForm). Those Web controls inside the Web Form are children of the Web Form.

Since server controls can have children, and each of their children may have children, and so on, a control and its descendents form a tree of controls. This tree of controls is called the control hierarchy. The root of the control hierarchy for an ASP.NET Web page is the Page-derived class that is autogenerated by the ASP.NET engine.

Whew! Those last few paragraphs may have been a bit confusing, as this is not the easiest subject to discuss or digest. To clear out any potential confusion, let's look at a quick example. Imagine you have an ASP.NET Web page with the following HTML portion:

<html>
<body>
  <h1>Welcome to my Homepage!</h1>
  <form runat="server">
    What is your name?
    <asp:TextBox runat="server" ID="txtName"></asp:TextBox>
    <br />What is your gender?
    <asp:DropDownList runat="server" ID="ddlGender">
      <asp:ListItem Select="True" Value="M">Male</asp:ListItem>
      <asp:ListItem Value="F">Female</asp:ListItem>
      <asp:ListItem Value="U">Undecided</asp:ListItem>
    </asp:DropDownList>
    <br />
    <asp:Button runat="server" Text="Submit!"></asp:Button>
  </form>
</body>
</html>

When this page is first visited, a class will be autogenerated that contains code to programmatically build up the control hierarchy. The control hierarchy for this example [is shown below:]

This concept of a control hierarchy works just the same with a DataGrid. Specifically, a DataGrid contains a child control for each of its rows. Each of these row controls contains a child for each of its columns. And each column control may contain further controls. For ButtonColumns, the column control would contain a single child control - either a Button or LinkButton control. For a TemplateColumn, the column control would contain its own hierarchy of children that composed the HTML markup and Web controls specified in the template.

For example, imagine we had a DataGrid with two columns, a ButtonColumn and a BoundColumn. When binding the DataGrid to a DataSource with three records, the DataGrid's control hierarchy might look like the following:

Bubbling Basics
When one of the DataGrid's Buttons are clicked, the Button's Command event is fired. When this happens we also want to have the DataGrid's ItemCommand event fire, but as the above figure illustrates, there is a bit of distance between the Button instance that was clicked and the DataGrid control. Event bubbling is employed to percolate the event from the Button control up to the DataGrid, where the ItemCommand event can be raised in response.

Event bubbling works using two protected methods of the Control class:

  • RaiseBubbleEvent(source, eventArgs) - when called, a specified event's information is bubbled up to control's parent. The source parameter is typically a reference to the object doing the bubbling (the actual Button control in the DataGrid example), whereas the eventArgs contains information about the event being bubbled (in the DataGrid example, the Button's CommandEventArgs information is percolated up, which includes the Button's CommandName and CommandArgument parameters).
  • OnBubbleEvent(source, eventArgs) - when an event is bubbled up to a control, the control's OnBubbleEvent() method fires. A control in the hierarchy may override this method to do some custom processing on the bubbled event. In the DataGrid's case, the OnBubbleEvent() method checks to see if a CommandEventArgs instance is being bubbled up. If so, it raises its own ItemCommand event. (This is a slight simplification of how things really work with the DataGrid.)

    The OnBubbleEvent() method returns a Boolean value that indicates if bubbling of the event should continue. If OnBubbleEvent() returns False, the event continues to bubble up the hierarchy; if it returns True, the bubbling of that event ends. By default, a control's OnBubbleEvent() returns False, thereby allowing event bubbling to progress unimpeded.

To demonstrate event bubbling, image that the Button in the third DataGrid row is clicked. Clicking the Button causes a postback and raises the appropriate Button control's Click event handler. The Button (and LinkButton) Web control's are coded such that when their Command event is fired, the event details are bubbled up the hierarchy. Specifically, the OnCommand() method in the Button and LinkButton classes looks as follows (comments added by yours truly):

Protected Overridable Sub OnCommand(ByVal e As CommandEventArgs)
  'OnCommand is passed in the CommandEventArgs for the event...
  Dim handler1 As CommandEventHandler = _
       CType(MyBase.Events.Item(Button.EventCommand), CommandEventHandler)

  If (Not handler1 Is Nothing) Then
    'This raises the event...
    handler1.Invoke(Me, e)
  End If

  'The call to RaiseBubbleEvent starts the percolation of the
  'event up the control hieracrhy.
  MyBase.RaiseBubbleEvent(Me, e)
End Sub

This event is then bubbled up to the ButtonColumn, calling its OnBubbleEvent() method, which, by default, does nothing, thereby letting the bubbling continue. Following that, the DataGridItem's OnBubbleEvent() method is called. The DataGridItem's OnBubbleEvent() checks to see if a CommandEventArgs object is being bubbled up and, if so, it crafts an instance of the DataGridCommandEventArgs object based on the passed-in CommandEventArgs object. This new type is then bubbled up to its parent (the DataGrid) and event bubbling is ceased. Here's the code from the DataGridItem's OnBubbleEvent() method:

Protected Overrides Function OnBubbleEvent(ByVal source As Object, _
                                           ByVal e As EventArgs) As Boolean
  If TypeOf e Is CommandEventArgs Then
     'Craft a DataGridCommandEventArgs object from the CommandEventArgs...
     Dim args1 As New DataGridCommandEventArgs(Me, _
                           source, CType(e, CommandEventArgs))

     'Bubble the new DataGridCommandEventArgs
     MyBase.RaiseBubbleEvent(Me, args1)

     'Stop the bubbling of the CommandEventArgs
     Return True
  End If

  'If we are dealing with something other than a CommandEventArgs,
  'let the bubbling proceed unmolested...
  Return False
End Function

Finally, in the DataGrid's OnBubbleEvent() method a check is made to see if a DataGridCommandEventArgs object has been bubbled up. If so, it halts the bubbling and raises its ItemCommand event. (Note that the DataGrid's OnBubbleEvent() method is a bit more complex than the DataGridItem's because the DataGrid might raise a number of events based on the CommandName value in the DataGridCommandEventArgs object. (For example, a CommandName of Edit raises the EditCommand event, a CommandName of Update raises the UpdateCommand event, and so on. Of course, regardless of the CommandName the ItemCommand always fires.)

The following figure depicts the chain of events just described:

Conclusion
In this article we saw how event bubbling is used to percolate events up the control hierarchy. This technique is an invaluable one for control developers creating composite controls whose contents cannot be determined until runtime. The most common Web control that fits into this class is the DataGrid, although both the DataList and Repeater use event bubbling in a similar manner. For more information on creating these types of controls, along with a further discussion on event bubbling, be sure to read Building DataBound Templated Custom ASP.NET Server Controls.

Happy Programming!

  • By Scott Mitchell

    Windows Internet Technology | ASP Articles | ASPMessageboard.com | ASPFAQs.com | ASP.NET | Advertise | Feedback | Awards | Author an Article

    • JupiterWeb networks:

    Search JupiterWeb:

    Jupitermedia Corporation has three divisions:
    JupiterImages, JupiterWeb and JupiterResearch

    Copyright 2005 Jupitermedia Corporation All Rights Reserved.
    Legal Notices, Licensing, Reprints, & Permissions, Privacy Policy.

    Jupitermedia Corporate Info | Newsletters | Tech Jobs | Shopping | E-mail Offers


Behind the Scenes: Discover the Design Patterns You're Already Using in the .NET Framework -- MSDN Magazine, July 2005

MSDN
Search for

Advanced Search
* MSDN Magazine Home
* July 2005
* Search
* Source Code
* Back Issue Archive
* Column Archive
* Next Issue
* RSS
* Subscribe
* Order Back Issues
* Reader Services
* Meet the Staff
* Media Kit
* Special CD Offers
* Submit an Article
* Write to Us
* Corrections
* TechNet Magazine
MSDN Magazine
MSDN Home > MSDN Magazine > July 2005
Behind the Scenes

Discover the Design Patterns You're Already Using in the .NET Framework

Rob Pierry
This article discusses:
  • Common design patterns used in .NET Framework classes
  • Patterns used to implement the ASP.NET programming model and request pipeline
  • How patterns make programming tasks faster and easier
This article uses the following technologies:
.NET Framework and ASP.NET

Code download available at:
DesignPatterns.exe (122KB)

ecently, Microsoft has placed increasing emphasis on design patterns. If you are unfamiliar with patterns, suddenly being inundated with new terms and foreign-looking UML diagrams can be overwhelming. This emphasis on patterns, however, doesn't represent a shift in methodology so much as a change in vocabulary. The Microsoft® .NET Framework base class library (BCL) already makes extensive use of patterns, and you are probably familiar with the most common ones, even though you might not realize it yet.

In this article, I'll cover a basic overview of several common design patterns and how they are used in the BCL and other areas of the .NET Framework. In doing so, you can discover some of the motivation for why the Framework is designed the way it is, as well as make the abstract concepts of the patterns themselves more intuitively understandable.

Most of the patterns I'll be covering come from the canonical reference, Design Patterns by Erich Gamma, Richard Helm, Ralph Johnson, and John Vlissides, (Addison-Wesley, 1995). These authors are collectively known as the Gang of Four. The Gang of Four didn't invent these patterns, but they documented and formalized the good work others had been doing since the beginning of software development.

If you are already familiar with some of these patterns, feel free to read about those you aren't familiar with, since each section is relatively independent. The section on ASP.NET-related patterns requires familiarity with the request pipeline, a basic overview of which is provided in that section.

Within the .NET Framework, the use of some patterns is so prevalent that they have been built into programming languages themselves, instead of just represented by the class libraries. The first two patterns I will discuss, the Observer and the Iterator, are supported by various language features of both C# and Visual Basic® .NET. As you will see, they are an integral part of many common programming tasks.

Observer Pattern

Good object-oriented design emphasizes both encapsulation and loose coupling. In other words, classes should keep internal details private and also minimize their strict dependencies. In most applications, classes don't work in isolation; they interact with many other classes. A common scenario of class interaction occurs when one class (the Observer) needs to be notified when something changes in another (the Subject). For example, several Windows® Forms controls might need to update their display after a button is clicked. A simple solution would be to have the Subject call a specific method of the Observer whenever a change in state occurs. This introduces a host of problems, however. Now, since the Subject needs to know which method to call, it is tightly coupled to that specific Observer. Furthermore, if you need to add more than one Observer, you have to continue to add code for each method call to the Subject. If the number of Observers changes dynamically, this gets even more complex. You'll quickly end up with a brittle mess that's difficult to maintain.

Applying the Observer pattern helps to resolve this problem efficiently. You can decouple the Subject from the Observers so that Observers of any variety can easily be added and removed, at both design time and run time. The Subject maintains a list of interested Observers. Each time the Subject's state changes, it calls the Notify method on each Observer. Figure 1 shows a sample implementation. All classes designed to act as Observers implement the ICanonicalObserver interface, and all Subjects must derive from CanonicalSubjectBase. If a new Observer wants to monitor a Subject, the Add method easily handles this without having to change any code in the Subject class. Note also that each Subject only directly depends on the ICanonicalObserver interface, not any specific Observer.

While the Gang of Four's Observer pattern solves some of these problems, there are still some roadblocks, since subjects must inherit from a specific base class and Observers must implement a special interface. Thinking back to the Windows Forms button example, a solution emerges. The .NET Framework introduces delegates and events to solve these problems. If you have done any programming for ASP.NET or Windows Forms, then you have probably worked with events and event handlers. Events act as the Subject, while delegates act as Observers. Figure 2 shows an example of the Observer pattern, making use of events.

The Windows Forms Button control exposes a Click event which gets raised whenever the button is clicked. Any class designed to react to this event just needs to register a delegate with that event. The Button class doesn't depend on any of the potential Observers, and each Observer only needs to know the correct type of the delegate for the event (EventHandler, in this case). Since EventHandler is a delegate type and not an interface, each Observer doesn't need to implement an extra interface. Assuming it already contains a method with a compatible signature, it only needs to register that method with the event of the Subject. Through delegates and events, the Observer pattern lets you decouple Subjects and their Observers.

Iterator Pattern

Many programming tasks involve manipulating collections of objects. Whether these collections are simple lists or something more complex such as binary trees, you'll often need some way to get access to each object in the collection. In fact, depending on the collection, you may want several ways to access each object such as front to back, back to front, preorder or postorder. To keep the collection simple, the traversal code itself is often in its own class.

One of the most basic ways to store a list of objects is in an array. Array types are built into both Visual Basic .NET and C#. Both languages also have a loop structure that aids in iterating over arrays: foreach in C# and For Each in Visual Basic .NET. Here's an easy example of iterating over arrays:

int[] values = new int[] {1, 2, 3, 4, 5};
foreach(int i in values)
{
    Console.Write(i.ToString() + " ");
}
These statements make use of the iterator for the array behind the scenes. All you need to know is that you are guaranteed to have the loop run exactly once for each item in the array.

To make those statements work, the object referenced in the In expression must implement IEnumerable. Any collection of objects that implements the IEnumerable interface can be traversed (enumerated). This interface has a single method, GetEnumerator, that returns an object which implements IEnumerator. The IEnumerator class contains the code necessary to iterate through the collection. It has a property for the current object (Current) and methods to advance to the next object as well as start over (MoveNext, and Reset). All of the collection classes in the System.Collections namespace, as well as arrays, implement IEnumerable and can therefore be iterated over.

If you examine the Microsoft intermediate language (MSIL) generated by the C# compiler for any code that uses foreach, you can see that in most cases it just uses the IEnumerator to do the iteration (certain types, such as arrays and strings, are special cased by the compiler). Here you can see the IEnumerator approach for iterating over the same array shown previously:

int[] values = new int[] {1, 2, 3, 4, 5};
IEnumerator e = ((IEnumerable)values).GetEnumerator();
while(e.MoveNext())
{
    Console.Write(e.Current.ToString() + " ");
}

The .NET Framework uses the IEnumerable and IEnumerator interfaces to implement the Iterator pattern. The Iterator pattern lets you easily traverse a collection without exposing the inner workings of that collection. An Iterator class, an implementer of IEnumerator, is a separate class from the collection, which implements IEnumerable. The Iterator class maintains the state of the traversal (including what the current item is and whether or not there are more items to be traversed) outside of the collection itself. The algorithm for the traversal is contained in the Iterator as well. This way you can simultaneously have multiple Iterators, each traversing the same collection in wildly different ways, without adding any complexity to the collection class itself.

Decorator Pattern

Any useful executable program involves either reading input, writing output, or both. Regardless of the source of the data being read or written, it can be treated abstractly as a sequence of bytes. .NET uses the System.IO.Stream class to represent this abstraction. Whether the data involves characters in a text file, TCP/IP network traffic, or something else entirely, chances are you will have access to it via a Stream. Since the class for working with file data (FileStream) and the class for working with network traffic (NetworkStream) both inherit from Stream, you can easily write code that processes the data independent of its origins. Here's a method for printing out some bytes from a Stream to the console:

public static void PrintBytes(Stream s)
{
    int b;
    while((b = fs.ReadByte()) >= 0)
    {
        Console.Write(b + " ");
    }
}

Reading a single byte at a time is typically not the most efficient way to access a stream. For example, hard drives are capable of (and optimized for) reading continuous blocks of data from the disk in a big chunk. If you know you are going to be reading several characters, it is better to read a chunk from the disk all at once and then consume the chunk from memory byte by byte. The Framework includes the BufferedStream class for doing just that. The constructor for BufferedStream takes as the parameter whatever stream you would like buffered access to. BufferedStream overrides the main methods of Stream, such as Read and Write, to provide more functionality. Since it is still a child class of Stream, you can use it the same as any other Stream (note that FileStream includes its own buffering capabilities). Similarly, you can use System.Security.Cryptography.CryptoStream to encrypt and decrypt Streams on the fly, without the rest of the application needing to know anything more than the fact that it is a Stream. Figure 3 shows several calls to my printing method using different Streams.

Figure 4 Using the Decorator Pattern
Figure 4 Using the Decorator Pattern

This ability to dynamically attach new functionality to objects transparently using composition is an example of the Decorator pattern, as shown in Figure 4. Given any instance of Stream, you can add the capability for buffered access by wrapping it in a BufferedStream, without changing the interface to the data. Since you are just composing objects, this can be done at run time, rather than using a technique like inheritance, which is a compile-time decision. The core functionality is defined either by an interface or by an abstract class (like Stream) from which all the Decorators derive. The Decorators themselves implement (or override) the methods in the interface (or base class) to provide the extra functionality. BufferedStream, for example, overrides Read to read from a buffer fed by the wrapped Stream, instead of reading from that Stream directly. As Figure 3 illustrates, any composition of Decorators, no matter how complex, can still be used as if it were only the base class.

Adapter Pattern

One of the strengths of the .NET Framework is backward compatibility. From .NET-based code you can easily call legacy COM objects and vice versa. In order to use a COM component in your project, all you have to do is add a reference to it via the Add Reference dialog in Visual Studio .NET. Behind the scenes, Visual Studio® .NET invokes the tlbimp.exe tool to create a Runtime Callable Wrapper (RCW) class, contained in an interop assembly. Once the reference has been added (and the interop assembly has been generated for you), the COM component can be used like any other class in managed code. If you were looking at code someone else had written without seeing the list of references (and without examining metadata associated with the classes or their implementation), you would be unable to tell which classes were written in a .NET-targeted language and which were COM components.

The magic that makes this happen is contained in the RCW. COM components have different error handling mechanisms and also make use of different data types. For example, strings in the .NET Framework use the System.String class while COM might use a BSTR. When calling a COM component with a string parameter from .NET-based code, though, you can pass in a System.String just like you would to any other similar managed code method. Inside the RCW, this System.String is converted into a format that the COM component expects, like a BSTR, before the COM call is made. Similarly, a method call on a COM component typically returns an HRESULT to indicate success or failure. When a COM method call returns an HRESULT that indicates that the call failed, the RCW turns this into an exception (by default), so it can be handled like all other managed code errors.

By allowing managed classes and COM components to interact despite their interface differences, RCWs are an example of the Adapter pattern. The Adapter pattern lets you adapt one interface to another. COM doesn't understand the System.String class, so the RCW adapts it to something that it can understand. Even though you can't change how a legacy component works, you can still interact with it. Adapters are frequently used like this.

The Adapter class itself wraps an Adaptee, translating all calls from the client into the appropriate format and sequence of calls. Though this sounds similar to the Decorator, there are several key differences. With a Decorator, the interfaces of the objects you're composing are the same, while the entire point of an Adapter is to allow you to change interfaces.Adapters also have a definite sequence to them; the Adaptee must be contained by the Adapter. A Decorator class doesn't need to know whether it is wrapped by 1 or 500 other classes, since the interfaces are all the same. As a result, the use of Decorators can be transparent to the application, while the use of Adapter cannot.

Factory Pattern

There are many cases in the Framework where you can obtain a new instance of a struct or class without calling its constructor yourself. The System.Convert class contains a host of static methods that work like this. To convert an integer to a Boolean, for example, you can call Convert.ToBoolean and pass in the integer. The return value of this method call is a new Boolean set to "true" if the integer was non-zero and "false" otherwise. The Convert class creates the Boolean for you with the correct value. Other type conversion methods work similarly. The Parse methods on Int32 and Double return new instances of those objects set to the appropriate value given only a string.

This strategy for creating new object instances is known as a Factory pattern. Rather than invoking the object's constructor, you can ask the object factory to create the instance for you. That way, the factory class can hide the complexity of object creation (like how to parse a Double out of a string). If you wanted to change the details of creating the object, you'd only have to change the factory itself; you would not have to change every single place in the code where the constructor is called.

These type conversion methods are one variant of this pattern, since you're not required to use the factory to create the objects in question. A more pure example of this pattern is the System.Net.WebRequest class, used to make a request and receive a response from a resource on the Internet. FTP, HTTP, and file system requests are supported by default. To create a request, call the Create method and pass in a URI. The Create method itself determines the appropriate protocol for the request and returns the appropriate subclass of WebRequest: HttpWebRequest, FtpWebRequest (new to the .NET Framework 2.0), or FileWebRequest. The caller doesn't need to know the specifics of each protocol, only how to invoke the factory and work with the WebRequest that gets returned. If the URI changes from an HTTP address to an FTP address, the code won't have to change at all. This is another common use of the Factory pattern. The parent class acts as a factory and returns a specific derived class based on parameters the client passes in. As in the WebRequest example, this hides the complexity of selecting an appropriate derived class from the caller.

Strategy Pattern

Both Array and ArrayList provide the capability to sort the objects contained in the collection via the Sort method. In fact, ArrayList.Sort just calls Sort on the underlying array. These methods use the QuickSort algorithm. By default, the Sort method will use the IComparable implementation for each element to handle the comparisons necessary for sorting. Sometimes, though, it is useful to sort the same list in different ways. For example, arrays of strings might be sorted with or without case sensitivity. To accomplish this, an overload of Sort exists that takes an IComparer as a parameter; IComparer.Compare is then used for the comparisons. This overload allows users of the class to use any of the built-in IComparers or any of their own making, without having to change or even know the implementation details of Array, ArrayList, or the QuickSort algorithm.

Leaving the choice of comparison algorithm up to the user of the class like this is an example of the Strategy pattern. The use of Strategy lets a variety of different algorithms be used interchangeably. QuickSort itself only requires a way to compare objects to each other. By calling Compare through a provided interface, the caller is free to substitute whatever particular comparison algorithm fits its specific needs. The code for the QuickSort can remain unchanged.

Figure 5 Strategy in Action
Figure 5 Strategy in Action

One of the new generic collections in version 2.0 of the .NET Framework, List<T>, also makes heavy use of the Strategy pattern, shown in Figure 5. In addition to the updated Sort method, the find-related methods, BinarySearch, and others all take parameters that allow parts of the respective algorithms to vary based on the needs of the caller. The use of a Predicate<T> delegate in the FindAll<T> method lets the caller use any method as a filter for the List<T> so long as it takes the appropriate object type and returns a Boolean. Combined with anonymous methods (another new C# language feature in version 2.0), clients can easily filter lists based on properties and methods of the objects in the list, without introducing dependencies into the List<T> class itself. Using the Strategy pattern lets complicated processes like sorting be easily modified to fit a caller's specific purpose, meaning you'll be able to write and maintain less code.

Composite Pattern in ASP.NET

The ASP.NET request/response pipeline is a complex system. Patterns are used in the design of the pipeline itself and in the control architecture to effectively balance its performance with extensibility and ease of programming. Before delving into the pipeline, however, I'll examine the patterns used in the programming model itself.

When dealing with collections of objects, there are often operations that are appropriate for both a single object and the entire collection. Think about an ASP.NET control. A control may be a simple single item like a Literal, or it could be composed of a complex collection of child controls, like a DataGrid is. Regardless, calling the Render method on either of these controls should still perform the same intuitive function.

When each item in the collection might itself contain collections of other objects, the use of the Composite pattern is appropriate. Composite is an easy way to represent tree-like collections without having to treat parent and leaf nodes differently.

The canonical example of Composite relies on an abstract base class, Component, that contains both methods for adding and removing children, and the operations common among parents and children. ASP.NET uses this formulation exactly with System.Web.UI.Control. Control represents the Component base class. It has operations for dealing with children (such as the child Controls property) as well as standard operations and properties like Render and Visible. Each object, whether a primitive object (like Literal) or a composite of several objects (like DataGrid), inherits from this base class.

Because the domain of controls is so diverse, there are several intermediate derived classes like WebControl and BaseDataList that serve as base classes for other controls. Though these classes expose additional properties and methods, they still retain the child management functions and core operations inherited from Control. In fact, the use of the Composite pattern helps to hide their complexity, if desired. Regardless of whether a control is a Literal or a DataGrid, the use of Composite means you can just call Render and everything will sort itself out.

Template Method Pattern

When the standard library of ASP.NET controls doesn't meet your needs, you have several options on how to create your own. For simple controls that only need to be used in a single project, a user control is often the best choice. When the control is to be used in several Web applications or requires more functionality, a custom server control may be a better fit.

When dealing with custom controls, there are two general types: controls that combine the functionality of several existing controls (called composite controls), and controls with a unique visual representation. The process for creating both of these types is very similar. For composite controls, you create a new class that inherits from one of the control base classes (like Control or WebControl) and then override the CreateChildControls method. In this method you add the controls whose functionality you are combining to the collection of child controls, called Controls. For other custom controls, you override Render instead and use the HtmlTextWriter parameter to output the HTML for your control directly.

Regardless of which style of custom control you choose, you don't have to write any code to handle the functionality that's common to all controls, like loading and saving ViewState at the right time, allowing PostBack events to be handled, and making sure the control lifecycle events are raised in the correct order. The main algorithm for how a control should be loaded, rendered, and unloaded is contained in the control base class.

The specifics of your particular control are handled at well-defined places in the control algorithm (the CreateChildControls or Render methods). This is an example of the Template Method pattern. The main algorithm skeleton is defined in a base class and subclasses can then plug in their own details without affecting the algorithm itself, as shown in Figure 6. A composite control and a custom control both share the same general lifecycle, but they can end up with drastically different visual representations.

Figure 6 Template Method Pattern
Figure 6 Template Method Pattern

This pattern is similar to the Strategy pattern. These two patterns differ in scope and in methodology. Strategy is used to allow callers to vary an entire algorithm, like how to compare two objects, while Template Method is used to vary steps in an algorithm. Because of this, Strategy is more coarsely grained. There can be vast differences between different client implementations, while with Template Method the algorithm remains fundamentally the same. The other main difference is that Strategy uses delegation while Template Method uses inheritance. In the sorting example of Strategy, the comparison algorithm is delegated to the IComparer parameter, but with custom controls you subclass the base and override methods to make changes. Both, however, let you easily alter processes to fit your specific needs.

Patterns in the ASP.NET Pipeline

When a client requests an ASPX page from the Web server, the request travels through many steps before ultimately ending up as HTML displayed by the client's browser. First, the request is processed by IIS and routed to the appropriate ISAPI extension. The ISAPI extension for ASP.NET (aspnet_isapi.dll) routes the request to the ASP.NET worker process.

Figure 7 ASP.NET Request Pipeline
Figure 7 ASP.NET Request Pipeline

At this point, the request begins to interact with classes that you are used to dealing with. The request is passed to an HttpApplication. Usually this is the class created in the codebehind file for Global.asax. The HttpApplication then passes the request through any number of HTTP Modules. These classes implement the IHttpModule interface and have a chance to modify the request (or even halt the processing of it) before it gets passed on to the next module. ASP.NET provides some standard modules which provide functionality you're probably familiar with, including FormsAuthenticationModule, PassportAuthenticationModule, WindowsAuthenticationModule, and SessionStateModule, all of which provide exactly the functionality that their names imply.

Ultimately, the request ends up at an IHttpHandler, the most common of which is System.Web.UI.Page. Inside the IHttpHandler.ProcessRequest method, Page raises appropriate events (like Init, Load, and Render), handles ViewState, and provides the programming model for ASP.NET. Figure 7 shows an outline of this process.

Several of the patterns employed by this process are more thoroughly documented in another standard reference for patterns, Martin Fowler's Patterns of Enterprise Application Architecture (Addison-Wesley, 2002).

Intercepting Filter Pattern

Once a request has made it into an HttpApplication, it passes through any number of IHttpModules. Each module is independent and has only a limited amount of control over the order in which it is invoked. The HttpApplication class exposes a sequence of events that get raised as the request makes its way through processing. These events include BeginRequest, AuthenticateRequest, AuthorizeRequest, and EndRequest. When the HttpApplication loads a module, it calls the Init method of the IHttpModule interface, allowing the module to register for any of the events it cares about. As a given request is handled, the events are raised in the appropriate order and all registered modules get a chance to interact with the request. The module can therefore control the stage at which it gets invoked, but not the exact order within that stage.

These modules are an example of the Intercepting Filter pattern. This pattern represents a chain of filters that are each in turn given a chance to modify a request (or message) that passes through them. Figure 8 shows a simplified flow diagram of this process. The key ideas of this pattern are that the filters are independent; filters can modify the request as it passes through.

Figure 8 Request Flow
Figure 8 Request Flow

There are several different implementation variations of the Intercepting Filter pattern, one of which is the event-based model employed by ASP.NET. A simpler variant involves maintaining a list of filters and iterating over it, invoking a method on each one in turn. This is how the Web Services Enhancements (WSE) for ASP.NET Web services uses this pattern. Each filter either extends SoapInputFilter (for request messages) or SoapOutputFilter (for responses), overriding the ProcessMessage method to perform the work of the filter.

Another option is to implement Intercepting Filter via the Decorator pattern. Then each filter would wrap its successor, performing preprocessing, invoking the successor, and then performing post-processing. The chain would be built using recursive composition, from back to front. This pattern is used to implement .NET Remoting channel sinks.

Regardless of implementation, the result is a dynamically configurable chain of independent filters. Since they are independent, these filters can easily be reordered and reused in other applications. Common tasks like authentication or logging can be encapsulated in a filter and used over and over. These tasks can then be handled by the filter chain before a request even reaches the HttpHandler, keeping the handler code cleaner.

Page Controller Pattern

System.Web.UI.Page implements a core part of the programming model for ASP.NET. Whenever you want to add a logical page to a Web application, you can create a Web Form (represented by an ASPX file and its codebehind). You can then write code to handle the specific demands of the new page, whether through handling page-level events, displaying a set of controls, or loading and manipulating data. Each logical page in the application has a corresponding Web Form that controls its behavior and regulates its presentation.

The practice of having one controller for each logical page is an example of the Page Controller pattern. This idea is fundamental to ASP.NET. When a logical page is requested via its URI, the ASP.NET runtime resolves the address to the corresponding subclass of Page and uses that class to handle the request. All the details about what a page looks like, what user input it can handle, and how it responds to that input are contained in a single place. When a logical page in the application requires changes, no other pages are affected. It's an abstraction that's so common we don't even think about it.

One of the drawbacks usually associated with the pure implementation of Page Controller is that common code must be repeated for each page. ASP.NET avoids this drawback by including other patterns in the pipeline implementation, as well as providing System.Web.UI.Page as a common base class for all Page Controllers. Cross-cutting concerns like authentication and session state are handled by the HttpModule Intercepting Filters and raising page lifecycle events, and other activities, are handled by the base class.

Other Web Presentation Patterns in ASP.NET

In addition to Intercepting Filter and Page Controller, ASP.NET makes use of variations of several other Web presentation patterns. When ASP.NET determines which HttpHandler to pass a request to, it uses something similar to a Front Controller. Front Controller is characterized by a single handler for all requests (like System.Web.UI.Page). Once the request reaches the Page class, though, the Page Controller pattern takes over.

Within the ASP.NET implementation of Page Controller, there are elements of the Model View Controller pattern. Model View Controller separates the model (business objects, data, and processes) from the view (the display of information). The controller responds to user input and updates the model and view. Roughly speaking, an ASPX page represents the View while its codebehind file represents a hybrid Model-Controller. If you were to pull all business and data-related code out of the codebehind and leave only event handling code, this would turn the codebehind into a pure Controller while the new class containing the business logic would be the Model.

Since these variations diverge from the canonical form of the patterns, they won't be covered here. Martin Fowler's book and the Microsoft Patterns site are good sources for more discussion.

Conclusion

Now that I have examined instances of common patterns in use throughout the .NET Framework and BCL, it should be even easier to recognize those same patterns in code you work with every day. Hopefully highlighting the design patterns underlying common classes and functionality has given you a better sense of what those patterns are and the benefits they provide. Trying to imagine UI programming without the Observer pattern or collections without an Iterator shows how indispensable these frameworks really are. Once you understand what each does, it becomes another valuable tool to add to your toolbox.

Rob Pierry is a Senior Consultant with Geniant, a leading enterprise IT consulting company specializing in Service Oriented Architecture. He can be reached at rpierry+msdn@gmail.com.
Subscribe From the July 2005 issue of MSDN Magazine.
Back to top Back to top QJ: 050705

Manage Your Profile |Legal |Contact us |MSDN Flash Newsletter
© 2005 Microsoft Corporation. All rights reserved. Terms of Use |Trademarks |Privacy Statement
 Microsoft


The Code Models Of ASP.NET 2.0

.NET
The Code Models Of ASP.NET 2.0

Posted by scott on Wednesday, June 01, 2005

ASP.NET 2.0 continues to offer code-behind and single file models for ASP.NET web form development, but picking a winner between the two is a difficult task.

The typical web form consists of controls (like labels, buttons, and data grids), and programming logic. In ASP.NET 2.0, there are two approaches to managing these control and code pieces: the single-file page model and the code-behind page model. Regardless of which model you choose, it’s important to understand how the runtime is processing and executing your web forms behind the scenes. In this article, we will examine how web forms move from design time to run-time in ASP.NET 2.0.

The Code-Behind Model

Visual Studio creates a web form using the code-behind model when you add a new web form to a project and check the “Place code in separate file” checkbox in the Add New Item dialog. Visual Studio will add two files to the project: an aspx file and a .cs or .vb file. If we were creating a Default.aspx web page, the aspx file would look like the following.

<%@

Page Language="C#" AutoEventWireup="true"

CodeFile="Default.aspx.cs" Inherits="_Default"

%>

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.1//EN" "http://www.w3.org/TR/xhtml11/DTD/xhtml11.dtd">

<html xmlns="http://www.w3.org/1999/xhtml" >

<head runat="server">

<title>Untitled Page</title>

</head>

<body>

<form id="form1" runat="server">

<div>

</div>

</form>

</body>

</html>

The ASPX page contains the typical markup for a form, including the html, head, and body tags. Any controls we add to the form using the designer will appear inside the ASPX file also. The three key pieces for us to focus on are in the @ Page directive on top. The AutoEventWireup attribute defaults to true, and we will return to this attribute later in the article. The CodeFile attribute is the link to the source code file with the programming logic for this web form, in this case the file is Default.aspx.cs. The runtime will use the CodeFile attribute to determine which source code file it needs to compile for this ASPX page. Likewise, the Inherits attribute tells the runtime the name of the class it will use as a base class for this web form, and again we will see how this works shortly when we see the entire picture. For now, let’s look at the CodeFile (code-behind) file for the ASPX page.

using System;

using System.Web.UI;

public partial class _Default : System.Web.UI.Page

{

protected void Page_Load(object sender, EventArgs e)

{

}

}

Here we find the _Default class (which we saw in the Inherits attribute) and our standard Page_Load event handler which (note: some non-essential using directives have been removed from the listing to conserve space). We typically use the Page_Load even handler to initialize controls and perform data binding. Currently, in VB.NET, the default .vb file will not contain the Page_Load event handler, but you can easily add the event handler using the page event drop down list just above the text editor. In either language, the key to focus on is the ‘partial’ keyword.

The partial keyword (new in .NET 2.0) is one of the rare keywords that is present in both C# and VB.NET and carries the same meaning (shocker!). Partial allows us to split a class definition across two or more source code files. In previous version of the .NET framework this was impossible to achieve – a class definition had to exist inside of a single .cs or .vb file.

The partial keyword plays an important role because it will allow the runtime to extend the definition of our _Default class with additional members. For instance, any control appearing in the ASPX markup with runat=”server” and an id attribute will ultimately act like a member variable in our class. For example, in the Page_Load event handler we can already access a variable named form1 – form1 represents the HTML form tag in the ASPX, which does have runat=”server” specified. How does all the magic happen? Let’s take a look at what happens when we browse to the web application to execute the form.

Compilation In The Code-Behind Model

When an incoming browser request arrives for our web form, the ASP.NET runtime needs to accomplish two tasks. First, the runtime needs to parse and understand the controls we’ve placed in the ASPX file. Parsing involves reading the ASPX portion of the form, and generating source code to create those controls and HTML markup. The second job is then to compile the generated source code. You can actually see the code the runtime generates by poking around in the ‘Temporary ASP.NET Files’ directory, which will reside underneath the framework installation in the \Microsoft.NET\Framework\v2.0.50215\Temporary ASP.NET Files. The following is an excerpt of the file generated by parsing the ASPX at the top of this article. Although a good portion of the actual code is omitted from this example, the snippet will give us a good idea of how the runtime is putting pieces together underneath the covers.

public partial class _Default : System.Web.SessionState.IRequiresSessionState

{

protected System.Web.UI.HtmlControls.HtmlForm form1;

protected System.Web.Profile.DefaultProfile Profile

{

get

{

return ((System.Web.Profile.DefaultProfile)(this.Context.Profile));

}

}

protected System.Web.HttpApplication ApplicationInstance

{

get

{

return ((System.Web.HttpApplication)(this.Context.ApplicationInstance));

}

}

}

namespace ASP

{

public class Default_aspx : _Default

{

public Default_aspx()

{

// ...

}

protected override void FrameworkInitialize()

{

base.FrameworkInitialize();

this.__BuildControlTree(this);

this.AddWrappedFileDependencies(ASP.Default_aspx.__fileDependencies);

this.Request.ValidateInput();

}

// ...

}

}

The first piece to notice is the partial class definition at the top of the generated code. This partial class will complete the _Default class definition from our Default.aspx.cs code behind file by adding some additional members. One of these members is a field to represent the HTML form tag on the page (again, because it has a runat=”server” tag). Any other server controls we would place on the form would also become members of the class.

The second class (Default_aspx) in this generated file represents the ASPX page itself. This class inherits the _Default class and contains all the code needed to initialize the form, instantiate the server controls, and spit out literal HTML.

The runtime will compile both of these classes (_Default and _Default_aspx) into the same assembly. This assembly will be located in the temporary ASP.NET files directory.

Wired

One last question to answer is this: how does our Page_Load method get invoked? If you examine all of the code in the code-behind and in the generated files you’ll see no use of delegates in C#, nor any code with the Handles clause in VB.NET (these are the constructs generally used to wire up event handlers).

The answer is in the AutoEventWireup attribute back in the @ Page directive for Default.aspx. The AutoEventWireup attribute is set to true (and would default to true if not present). When true, the ASP.NET runtime will attempt to attach page methods to events based on the method names. If the method follows the convention of Page_EventName, then the method will be paired with an event by the name of EventName. For instance, the runtime will wire up Page_Load with the Load event, and Page_Init to the Init event. All of this happens without explicit delegates or Handles clauses.

The Single-File Page Model

In this section we will create a new Default.aspx webform, but leave the “Place code in a separate file” checkbox unchecked. We are also going to drag a Label control onto the form. The IDE will show us an ASPX file with the following contents.

<%@ Page Language="C#" %>

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.1//EN" "http://www.w3.org/TR/xhtml11/DTD/xhtml11.dtd">

<script runat="server">

</script>

<html xmlns="http://www.w3.org/1999/xhtml" >

<head runat="server">

<title>Untitled Page</title>

</head>

<body>

<form id="form1" runat="server">

<div>

<asp:Label ID="Label1" runat="server" Text="Label"></asp:Label>

</div>

</form>

</body>

</html>

There is no .cs or .vb file associated with the ASPX file, so the @ Page directive does not need any attributes indicating where the associated source code file resides. All of the logic we want to add to the page can appear inside the server side script tag. For instance, we could change the text of the label control by placing the following code inside the script block.

<script runat="server">

protected void Page_Load(object sender, EventArgs e)

{

Label1.Text = "Hello World!";

}

</script>

Remember AutoEventWireup defaults to true when not present in the @ Page directive, so the Page_Load method will automatically wire up to the page object’s load event. But what class is Page_Load a part of? We can see exactly what happens by looking for C# source code files in the temporary ASP.NET files directory when the web form executes. Here is an excerpt.

namespace ASP

{

public class Default_aspx : System.Web.UI.Page,

System.Web.SessionState.IRequiresSessionState

{

protected System.Web.UI.WebControls.Label Label1;

protected System.Web.UI.HtmlControls.HtmlForm form1;

protected void Page_Load(object sender, EventArgs e)

{

Label1.Text = "Hello World!";

}

public Default_aspx()

{

// ...

}

protected override void FrameworkInitialize()

{

base.FrameworkInitialize();

this.__BuildControlTree(this);

this.AddWrappedFileDependencies(ASP.Default_aspx.__fileDependencies);

this.Request.ValidateInput();

}

// ....

}

}

In the single-file page model, the ASP.NET runtime generates code for only a single class (Default_aspx). Compared to the code-behind model, which used two partial class declarations and an inherited class, the single file model does the same amount of work with fewer pieces. However, since the runtime is generating the extra pieces for us, we shouldn’t consider this an advantage.

And The Winner Is…

The obvious question is which model should you be using for your ASP.NET projects? The answer will largely depend on the type of person you are. Working from a single file containing both the code and ASPX markup will appeal to many people, while others will insist on a strict separation and favor the code-behind model. The single-file model has an advantage in configuration management and deployment, since there is only a single file to version and deploy. Intellisense and refactoring tools appear to work equally well with both models, so there will be no clear winner in the productivity category. One additional factor in deciding on the model to use is your pre-compilation strategy, which will be the topic of our next article.

by K. Scott Allen

Feel free to leave questions or comments about this article on my blog.

New Articles
Themes In ASP.NET 2.0
This article will provide an in-depth look at the Themes feature in ASP.NET.

Design Considerations for Cross Page Post Backs in ASP.NET 2.0
ASP.NET gives us three techniques to move processing to a new form: client redirection, a server-side transfer, and a cross page post back. In this article we will take a closer look at these three techniques.

Master Pages In ASP.NET 2.0
Master pages in ASP.NET are the key to building a professional web application with a consistent, easy to maintain layout.

Most Popular Articles
SQL Performance Tuning using Indexes
This article looks at general guidelines to creating effective indexes using short keys, distinct keys, covering indexes and clustered indexes.

Event Bubbling From Web User Controls in ASP.NET (C#)
This C# code example demonstrates event bubbling from a web user control (ASCX) to a parent page (ASPX) and the shows the flow of events through execution.

DropDownList Controls In an ASP.Net DataGrid
This article will demonstrate how to add a DropDownList control to each row of an ASP.Net DataGrid, including the header row. The article demonstrates how to perform data binding on each DropDownList control, and how to handle events when the DropDownList selection changes.

Contribute
The purpose of OdeToCode is to provide a forum where developers share thier knowledge. If you have an interesting article idea or a piece of code you wish to share with the developer community, have it published on OdeToCode. Just email us and let us know.


FTPOnline.com

FTP Online Welcome Guest!
Create Account | Login
Locator+ Code:

Search:
FTPOnline Channels Conferences Resources Hot Topics Partner Sites Magazines About FTP RSS 2.0 Feed

Thoughts and commentary from Jim Fawcette, president of Fawcette Technical Publications

Tuesday, July 05

Ballmer to Launch Visual Studio 2005 In San Francisco November 7
Posted 10:41 AM

At the opening keynote of its TechEd Europe conference in Amsterdam this morning, Microsoft announced more details on the joint launch of Visual Studio 2005, SQL Server 2005, and BizTalk Server 2006.

The main event will take place at the Moscone West conference center in downtown San Francisco on November 7th, with a keynote by Microsoft CEO Steve Ballmer, followed by 89 other events around the world. {Note: Moscone West will also be the site of FTP's VSLive! San Francisco conference January 30-February 3, 2006. VSLive! Sydney will serve as the launch event for Australia and New Zealand, November 28-December 2.

Other details in the keynote by Andy Lees, corporate vice president, focused on interoperability including some minor updates:

  • JDBC Driver for SQL Server, available at: http://www.microsoft.com/sqldownloads/2005/jdbc.mspx
  • Interoperability standards. Support of Section 508 of U.S. Rehabilitation Act and W3C's accessibility guidelines, plus ASP.NET 2.0 gnerates XHTML 1.0 markup by default.
  • VSTO. Office integration with emphasis on Outlook. Download of latest beta at: http://msdn.microsoft.com/office/understanding/vsto
  • SQL Server 2000 Reporting Services Pack for Microsoft Office Sharepoint Portal Server 2003 (a candidate for longest product name even in MS history), included eight predefined reports. Also released are similar reports for Axapta. Both can be downloaded from:
    http://www.microsoft.com/sql/reporting/downloads/default.mspx.

  # # #

-- 0 comments: - Post your own comment

Top

Post comment
Name:
Comment:
*The author name is required.
 *The comment text is required

< July 2005 >
>> Sun Mon Tue Wed Thu Fri Sat
> 26 27 28 29 30 1 2
> 3 4 5 6 7 8 9
> 10 11 12 13 14 15 16
> 17 18 19 20 21 22 23
> 24 25 26 27 28 29 30
> 31 1 2 3 4 5 6

Related Terms
Sorry, search results temporarily unavailable.

FTPOnline Blog Home

Recent Posts

• Websphere Family Grows
Posted 08/26/2005
• .... and The IBM Rational Tools
Posted 08/26/2005
• Google Wants Larger Pie
Posted 08/18/2005
• Google Chokes on its Own Dog-Food, Shuns CNET
Posted 08/10/2005
• Poor IT Career Prospects Deter Students
Posted 07/29/2005

BlogRoll

• Adam Bosworth
• Adam Nathan
• BEA dev2dev
• Chris Kinsman
• Dan Gillmor's eJournal
• Dino Esposito (.Net2TheMax)
• Don Box
• Enrico Sabbadin (.Net2TheMax)
• Eugenio La Mesa (.Net2TheMax)
• James Gosling
• Jimmy Nilsson (.Net2TheMax)
• John Lam's
Software Development Weblog
• John Montgomery
(A View From Elsewhere)
• Jonathan Schwartz
• Jon's Radio
• JRoller, Rick Ross
• Keith Pleas
• Longhorn Blogs
• Marco Bellinaso (.Net2TheMax)
• Marquee de Sells (Chris Sells)
• Mike Schinkel
• PDC Bloggers
• Ray Ozzie
• ScottGu's Blog
• Scott Mace
• Scripting News
• Sean Gallagher
• Simon Phipps
• Steve Gillmor
• TheArchitect.co.uk
• Tom Rizzo
• VS Data Team's WebLog
• Yasser Shohoud

Links

• VSLive!
• Java Pro Live!
• jGuru
• Enterprise Architect Summit

Java Pro | Visual Studio Magazine | Windows Server System Magazine
.NET Magazine | Enterprise Architect | XML & Web Services Magazine
VSLive! | Thunder Lizard Events | Discussions | Newsletters | FTP Home
© Copyright 2001-2005 Fawcette Technical Publications | Privacy Policy | Contact Us


Choose a Web Hosting Provider for your ASP.NET website

Author: Kristofer Gafvert
First Published: June 8, 2005
Last Updated: June 8, 2005
Last Reviewed: June 8, 2005
PDF: N/A
Download Code: N/A

Table of Contents

Table of Contents
Introduction
Make a list of what you actually need
Server-side techniques used
Disk space required
Bandwidth / Data Transfer
Database requirement
SSL
Email Services
Special Requirements
Evaluate the web hosting provider
Backup
Availability vs. Uptime
Reliability, speed of access
Knowledge
Security
Statistics
Deployment of your website
Management and configuration
Location
Support
Three general tips
Who owns the domain?
Nothing is free!
Don't believe in everything you read

Introduction

This article will not recommend any specific web hosting provider. It will instead give the reader useful information and guidance in how to find the best web hosting provider for their website. Each web application is unique and has its own demands, so it is not possible to give a complete "do this...check that". Instead this is more of a general guide.

The number of web hosting providers is huge. The price can range from free up to several thousands dollar per month. Most people are however looking for a web hosting provider in the range of $100 - $300 per year, and in my opinion, you should not go any cheaper than that (the old saying "You get what you pay for" applies to this business as well, so if you are serious with your website, do not go beneath $100, you will most likely get disappointed). But of course, I am not saying that all web hosting providers offering cheap services are "bad", but it is more difficult to find a great web hosting provider in that price range.

Make a list of what you actually need

The very first thing you should do is a list of what you actually need. Many people choose a web hosting provider based on what they offer (someone may offer PHP, but the organization have a website based on ASP.NET, and do not plan on using PHP), and not what they need. Remember that choosing a web hosting provider is not a one-time decision you do only once in your life time. If you later use something your current web hosting provider does not offer you can change web hosting provider! So your decision should be based on what you need today, or what you plan to need in the near future.

This list may contain:

Server-side techniques used

Do you use ASP.NET, ASP, PHP, JSP, or a combination of them?

Disk space required

This is quite easily to find out, since you (probably) already have developed your web application. But remember that if your visitors are allowed to upload content, you may need much more than what your web application is using alone. If you use a disk-based database (Microsoft Access for example), or store content in XML-files, the disk space required may also go beyond what was thought in the beginning.

Bandwidth / Data Transfer

First of all, these are not the same thing. When looking at web hosting plans, you probably see that you are limited to NN amount of data transfer per month. Some refers to this as bandwidth, but it is not. Usually, you do not have any option for bandwidth, but you have a limit of data transfer.

For a small to medium size website, you will not send anymore than 3 GB of data each month. In the beginning (when the website is not yet well-known), you can probably live with a limit of 1 GB. But remember that if you have many downloadable files (PDF, ZIP, MPG etc.), you can easily go above the limit of 3 GB.

Another thing to check out for is the viewstate. Many developers do not seem to understand the purpose of it, and when to turn it off for a control. A huge viewstate can drive up the amount of data transferred (and it also makes your pages slow because more data is transferred to the end-user).

The amount of data transferred each month is (in my opinion) difficult to calculate for in advance. So make sure that the web hosting provider has a flexible plan for this (i.e. you can pay extra for the traffic, without upgrading to another plan, and that this does not cost you unreasonable much money).

Database requirement

Microsoft Access (some people would argue if this really is a database :-) and MySQL are often included without no extra charge. SQL Server on the other hand can cost. And it can cost a lot! If you are using SQL Server, compare the cost between many web hosting providers, it can vary tremendous. Also check how much storage your database requires. Web hosting providers often charges more per MB of database storage, than they do for disk storage.

SSL

Does your website require SSL for secure communication (for example for credit card information)?

Email Services

Will you send out a newsletter? Do you need an emailing list? Do you need email, and how many do you need? Check with the web hosting provider so they support your needs.

Special requirements

Does your web application need some special configuration in IIS? For example mapping certain extensions to the ASP.NET ISAPI extension? Some web hosting providers may not want to do this on a shared server. So ask them before you decide you want to do business with them.

[ 1 ] [ 2 ] [ Next ]


IranASP.NET - صفحه اول

۱۳۸۴ جمعه ۱۵ مهر صفحه اول | مقالات | خبرها | درباره | آگهی در سايت | ارتباط با ما

سرمقاله
خداحافظ IranASP.NET!
مديريت سايت
داشتم می‌رفتم ديدم بدون خداحافظی بی معرفتی است. با "مقاله" شروع کردم، با "مقاله" هم به پايان می‌برم. اگر دنبال مطلب فنی هستيد، اين مقاله آخر را نخوانيد. اگر می‌خواهيد بدانيد که چرا می‌روم، اين گفتار کوتاه را بخوانيد. ۱۳۸۴/۷/۶
متن مقاله...
XML خبرها
101 مثال برای Visual Studio 2005 ۱۳۸۴/۶/۱۰ جديد!
الگوهای طراحی نرم افزار استفاده شده در دات نت ۱۳۸۴/۶/۱۰ جديد!
چگونه يک Host مناسب برای سايت ASP.NET خود انتخاب کنيم؟ ۱۳۸۴/۴/۲۳ جديد!
تبدیل تاریخهای میلادی، شمسی و قمری به یکدیگر با استفاده از Persia API ۱۳۸۴/۴/۱۹ جديد!
استيو بالمر کشتی Visual Studio 2005 را در تاريخ 7 نوامبر در سان فرانسيسکو به آب خواهد انداخت ۱۳۸۴/۴/۱۵ جديد!
چرا من از DataSet در برنامه‌های ASP.NET استفاده نمی‌کنم؟ ۱۳۸۴/۴/۷ جديد!
حبابی کردن Eventها در کنترل‌ها ۱۳۸۴/۴/۷ جديد!
» همه خبرها
» ارسال خبر
XML مقالات
برنامه نویسی شئ گرا در VB.NET (قسمت اول) جديد!
امروزه برنامه‌های کاربردی بر پایه شئ‌گرایی استوارند. تکنولوژی NET. امکانات بسیار جالب و کاملی در این زمینه دارد این مقاله که از کتاب ارزشمند Developing windows-based applications with microsoft VB... ۱۳۸۴/۴/۲۳
کوکی ها در ASP.NET جديد!
اين مقاله توضيح می دهد که چگونه می توان کوکی‌ها را با استفاده از ASP.NET ساخت، خواند و يا حذف کرد. ۱۳۸۴/۴/۷
کنترل‌های پویا جديد!
چگونگی اضافه کردن یک کنترل کاربری (User Control) در مواقع لازم با استفاده از متد LoadControl ۱۳۸۴/۳/۲
جستجو با استفاده از وب سرویس گوگل - قسمت دوم جديد!
گوگل به برنامه نویسان یک وب سرویس برای جستجو در دیتابیس خود پیشنهاد می کند. به کمک این وب سرویس شما قادر خواهید بود تا یک وب سایت مشخص یا کل وب را به کمک شاخص های گوگل جستجو کنید و نتایج را به صورت... ۱۳۸۴/۲/۲۶
جستجو با استفاده از وب سرویس گوگل - قسمت اول جديد!
گوگل به برنامه نویسان یک وب سرویس برای جستجو در دیتابیس خود پیشنهاد می کند. به کمک این وب سرویس شما قادر خواهید بود تا یک وب سایت مشخص یا کل وب را به کمک شاخص های گوگل جستجو کنید و نتایج را به صورت... ۱۳۸۴/۲/۷
» همه مقالات
» ارسال مقاله
جستجو: بگرد!
جستجوی پيشرفته
نام کاربری |
کلمه عبور |
 | ورود | عضويت

Proudly Hosted by:
IRAN Mizban Network

©۱۳۸۰-۱۳۸۴ IranASP.NET
آگهی در سايت | پيوند به ما | شرايط استفاده


IranASP.NET - صفحه اول

سرمقاله
خداحافظ IranASP.NET!
مديريت سايت
داشتم می‌رفتم ديدم بدون خداحافظی بی معرفتی است. با "مقاله" شروع کردم، با "مقاله" هم به پايان می‌برم. اگر دنبال مطلب فنی هستيد، اين مقاله آخر را نخوانيد. اگر می‌خواهيد بدانيد که چرا می‌روم، اين گفتار کوتاه را بخوانيد. ۱۳۸۴/۷/۶
متن مقاله...
XML خبرها
101 مثال برای Visual Studio 2005 ۱۳۸۴/۶/۱۰ جديد!
الگوهای طراحی نرم افزار استفاده شده در دات نت ۱۳۸۴/۶/۱۰ جديد!
چگونه يک Host مناسب برای سايت ASP.NET خود انتخاب کنيم؟ ۱۳۸۴/۴/۲۳ جديد!
تبدیل تاریخهای میلادی، شمسی و قمری به یکدیگر با استفاده از Persia API ۱۳۸۴/۴/۱۹ جديد!
استيو بالمر کشتی Visual Studio 2005 را در تاريخ 7 نوامبر در سان فرانسيسکو به آب خواهد انداخت ۱۳۸۴/۴/۱۵ جديد!
چرا من از DataSet در برنامه‌های ASP.NET استفاده نمی‌کنم؟ ۱۳۸۴/۴/۷ جديد!
حبابی کردن Eventها در کنترل‌ها ۱۳۸۴/۴/۷ جديد!
» همه خبرها
» ارسال خبر
XML مقالات
برنامه نویسی شئ گرا در VB.NET (قسمت اول) جديد!
امروزه برنامه‌های کاربردی بر پایه شئ‌گرایی استوارند. تکنولوژی NET. امکانات بسیار جالب و کاملی در این زمینه دارد این مقاله که از کتاب ارزشمند Developing windows-based applications with microsoft VB... ۱۳۸۴/۴/۲۳
کوکی ها در ASP.NET جديد!
اين مقاله توضيح می دهد که چگونه می توان کوکی‌ها را با استفاده از ASP.NET ساخت، خواند و يا حذف کرد. ۱۳۸۴/۴/۷
کنترل‌های پویا جديد!
چگونگی اضافه کردن یک کنترل کاربری (User Control) در مواقع لازم با استفاده از متد LoadControl ۱۳۸۴/۳/۲
جستجو با استفاده از وب سرویس گوگل - قسمت دوم جديد!
گوگل به برنامه نویسان یک وب سرویس برای جستجو در دیتابیس خود پیشنهاد می کند. به کمک این وب سرویس شما قادر خواهید بود تا یک وب سایت مشخص یا کل وب را به کمک شاخص های گوگل جستجو کنید و نتایج را به صورت... ۱۳۸۴/۲/۲۶
جستجو با استفاده از وب سرویس گوگل - قسمت اول جديد!
گوگل به برنامه نویسان یک وب سرویس برای جستجو در دیتابیس خود پیشنهاد می کند. به کمک این وب سرویس شما قادر خواهید بود تا یک وب سایت مشخص یا کل وب را به کمک شاخص های گوگل جستجو کنید و نتایج را به صورت... ۱۳۸۴/۲/۷
» همه مقالات
» ارسال مقاله
جستجو: بگرد!
جستجوی پيشرفته
نام کاربری |
کلمه عبور |
 | ورود | عضويت


An Error Occured

مشکلی در پاسخگويی به درخواست شما پيش آمده است.

دلايل متعددی می تواند سبب بروز اين مشکل گردد. اگر دفعاتی زيادی است که با اين مساله روبرو می گرديد، لطفا اين مساله را با ذکر جزئيات و مراحلی را که طی نموده ايد تا به اين مشکل برخورد کرده ايد را برای ما به آدرس Site [at] IranASP.net ارسال نمائيد.

با تشکر

An error occured while processing your request.

This error could be due to a number of possible factors. If you continue to see this page, please send a detailed report, including the exact steps you took before getting this page and send it to Site [at] IranASP.net.

Thank you.

©۱۳۸۰-۱۳۸۲ IranASP.NET


IranASP.NET - عضويت در سايت

عضويت در سايت

توجه: اگر شما قبلاً مشترک خبرنامه IranASP.NET بوده ايد، هم اکنون بطور خودکار مراحل عضويت شما انجام شده است. جهت اطلاع از نام کاربری و کلمه عبورتان، به صندوق پست الکترونيکی خود مراجعه نمائيد. در صورت عدم دريافت نامه حاوی اطلاعات کاربری خود، جهت اطلاع از نام کاربری و کلمه عبور خود به صفحه ارسال کلمه عبور مراجعه نمائيد.

با عضويت رايگان در سايت IranASP.NET، شما می‎توانيد به امکانات ويژه سايت دسترسی داشته باشيد. برخی از اين امکانات در حال حاضر عبارتند از اشتراک ماهنامه سايت، امکان ارسال خبر به نام خودتان. بتدريج امکانات ديگری به اين ليست اضافه خواهد شد که فقط برای اعضای سايت قابل دسترس خواهند بود.

با استفاه از فرم زير، يک نام کاربری دلخواه برای خود تعيين نموده و آدرس E-mail خود را نيز وارد نمائيد. سپس يک نامه به آدرس E-mail شما ارسال خواهد شد که در آن يک کلمه عبور برای شما تعيين شده است. شما می‎توانيد با استفاده از آن کلمه عبور و نام کاربری خود، بعنوان عضو، وارد سايت شده و سپس به کليه امکانات ويژه اعضای سايت دسترسی داشته و يا در صورت تمايل کلمه عبور خود را نيز تغيير دهيد.

نام کاربری | *
آدرس E-mail | * *
جستجو: بگرد!
جستجوی پيشرفته
نام کاربری |
کلمه عبور |


IranASP.NET - جستجو

جستجو

جستجوی IranASP.NET:

جستجو در:
جستجو: بگرد!
جستجوی پيشرفته
نام کاربری |
کلمه عبور |


IranASP.NET - ارسال کلمه عبور

ارسال کلمه عبور

اگر کلمه عبور يا نام کاربری خود را فراموش نموده ايد، ما آنها را برای شما می فرستيم.

دقت داشته باشيد که در صورت تقاضای شما جهت ارسال موارد فوق، يک کلمه عبور جديد برای شما در نظر گرفته خواهد.

لطفا آدرس E-mail خود را وارد نمائيد:
* *

آيا هنوز عضو نيستيد؟ جهت عضويت اينجا را کليک کنيد.
جستجو: بگرد!
جستجوی پيشرفته
نام کاربری |
کلمه عبور |


IranASP.NET - فارسی در وب

فارسی در وب

اين گروه از مقالات به موضوع خط فارسی در وب و سهم ايران يا زبان فارسی در دات نت می پردازد و سعی دارد تا کارهائی که در اين زمينه انجام می شود را حمايت و معرفی نمايد.

فارسی سازی Text. (۱۳۸۳/۴/۱۶)
توسط: مديريت سايت
يکی از خوانندگان وبلاگ ايميل زده بود که چگونه می توان Text. را فارسی کرد يا به عبارت ديگر من اين کار را چگونه انجام داده ام؟ فکر کردم که شايد اين موضوع برای شما هم سوال باشد، لذا تصميم گرفتم اندکی به...
چگونه صفحات فارسی خود را می سازيم؟ (۱۳۸۲/۶/۲۹)
توسط: مديريت سايت
مقاله ای در پاسخ به نامه های فراوان رسيده در مورد اينکه سايت IranASP.NET چگونه صفحات فارسی خود را می سازد.
اعداد فارسی (۱۳۸۱/۲/۲۹)
توسط: مديريت سايت
ارائه يک راه حل ساده برای حل مشکل نمايش اعداد فارسی در متون و سايتهای فارسی که از يونيکد استفاده کرده اند.
ايران در جهانی سازی دات نت (۱۳۸۰/۱۲/۲۵)
توسط: اميد خندان راد
بررسی جهانی سازی در دات نت و نقش و موقعيت فعلی ايران در آن
بررسی کلاس Globalization.CultureInfo (۱۳۸۰/۱۲/۲۵)
توسط: اميد خندان راد
بررسی مشخصات کشور ايران در کلاس CultureInfo
تقويم هجری شمسی (جلالی) (۱۳۸۰/۱۲/۲۵)
توسط: اميد خندان راد
پيشنهاد وارد کردن تقويم هجری شمسی به پروژه دات نت
طرح بندی صفحات فارسی (۱۳۸۰/۱۲/۱۱)
توسط: مديريت سايت
مهمترين مبحث در طرح بندی و ساخت صفحات فارسی در HTML با استفاده از بکارگيری DIR در تعيين جهت متن
زبان فارسی در HTML (۱۳۸۰/۱۱/۲۷)
توسط: مديريت سايت
چگونگی ساخت صفحات HTML بصورت فارسی با تعيين مجموعه نويسه و زبان مورد استفاده
پشتيبانی استاندارد يونی‌کد (۱۳۸۰/۹/۲۹)
توسط: مديريت سايت
بررسی پشتيبانی بين اللملی سازی در محيط های مختلف
فناوری‌ها‌ی مرتبط با يونی‌کد (۱۳۸۰/۹/۲۹)
توسط: مديريت سايت
بررسی ارتباط فناوری‌های مختلف مانند HTML و XML با يونی‌کد

« بعدی ۲ ۱ قبلی »

جستجو: بگرد!
جستجوی پيشرفته
نام کاربری |
کلمه عبور |
 | ورود | عضويت

Proudly Hosted by:
IRAN Mizban Network

Bookmark يادداشت آدرس Tell a friend توصيه به دوستان Print Friendly version نسخه مناسب چاپ


IranASP.NET - فارسی در وب

فارسی در وب

اين گروه از مقالات به موضوع خط فارسی در وب و سهم ايران يا زبان فارسی در دات نت می پردازد و سعی دارد تا کارهائی که در اين زمينه انجام می شود را حمايت و معرفی نمايد.

فارسی سازی Text. (۱۳۸۳/۴/۱۶)
توسط: مديريت سايت
يکی از خوانندگان وبلاگ ايميل زده بود که چگونه می توان Text. را فارسی کرد يا به عبارت ديگر من اين کار را چگونه انجام داده ام؟ فکر کردم که شايد اين موضوع برای شما هم سوال باشد، لذا تصميم گرفتم اندکی به...
چگونه صفحات فارسی خود را می سازيم؟ (۱۳۸۲/۶/۲۹)
توسط: مديريت سايت
مقاله ای در پاسخ به نامه های فراوان رسيده در مورد اينکه سايت IranASP.NET چگونه صفحات فارسی خود را می سازد.
اعداد فارسی (۱۳۸۱/۲/۲۹)
توسط: مديريت سايت
ارائه يک راه حل ساده برای حل مشکل نمايش اعداد فارسی در متون و سايتهای فارسی که از يونيکد استفاده کرده اند.
ايران در جهانی سازی دات نت (۱۳۸۰/۱۲/۲۵)
توسط: اميد خندان راد
بررسی جهانی سازی در دات نت و نقش و موقعيت فعلی ايران در آن
بررسی کلاس Globalization.CultureInfo (۱۳۸۰/۱۲/۲۵)
توسط: اميد خندان راد
بررسی مشخصات کشور ايران در کلاس CultureInfo
تقويم هجری شمسی (جلالی) (۱۳۸۰/۱۲/۲۵)
توسط: اميد خندان راد
پيشنهاد وارد کردن تقويم هجری شمسی به پروژه دات نت
طرح بندی صفحات فارسی (۱۳۸۰/۱۲/۱۱)
توسط: مديريت سايت
مهمترين مبحث در طرح بندی و ساخت صفحات فارسی در HTML با استفاده از بکارگيری DIR در تعيين جهت متن
زبان فارسی در HTML (۱۳۸۰/۱۱/۲۷)
توسط: مديريت سايت
چگونگی ساخت صفحات HTML بصورت فارسی با تعيين مجموعه نويسه و زبان مورد استفاده
پشتيبانی استاندارد يونی‌کد (۱۳۸۰/۹/۲۹)
توسط: مديريت سايت
بررسی پشتيبانی بين اللملی سازی در محيط های مختلف
فناوری‌ها‌ی مرتبط با يونی‌کد (۱۳۸۰/۹/۲۹)
توسط: مديريت سايت
بررسی ارتباط فناوری‌های مختلف مانند HTML و XML با يونی‌کد

« بعدی ۲ ۱ قبلی »

جستجو: بگرد!
جستجوی پيشرفته
نام کاربری |
کلمه عبور |


IranASP.NET - فارسی در وب

فارسی در وب

اين گروه از مقالات به موضوع خط فارسی در وب و سهم ايران يا زبان فارسی در دات نت می پردازد و سعی دارد تا کارهائی که در اين زمينه انجام می شود را حمايت و معرفی نمايد.

استاندارد يونی‌کد (۱۳۸۰/۹/۲۲)
توسط: مديريت سايت
معرفی استاندارد يونی‌کد و ويژگی‌های آن
خط فارسی در اينترنت (۱۳۸۰/۹/۲۱)
توسط: مديريت سايت
آشنائی با مشکلات زبان فارسی در اينترنت و کارهای در دست اقدام

« بعدی ۲ ۱ قبلی »

جستجو: بگرد!
جستجوی پيشرفته
نام کاربری |
کلمه عبور |


IranASP.NET - فارسی در وب

فارسی در وب اين گروه از مقالات به موضوع خط فارسی در وب و سهم ايران يا زبان فارسی در دات نت می پردازد و سعی دارد تا کارهائی که در اين زمينه انجام می شود را حمايت و معرفی نمايد.

فارسی سازی Text. (۱۳۸۳/۴/۱۶)
توسط: مديريت سايت
يکی از خوانندگان وبلاگ ايميل زده بود که چگونه می توان Text. را فارسی کرد يا به عبارت ديگر من اين کار را چگونه انجام داده ام؟ فکر کردم که شايد اين موضوع برای شما هم سوال باشد، لذا تصميم گرفتم اندکی به...
چگونه صفحات فارسی خود را می سازيم؟ (۱۳۸۲/۶/۲۹)
توسط: مديريت سايت
مقاله ای در پاسخ به نامه های فراوان رسيده در مورد اينکه سايت IranASP.NET چگونه صفحات فارسی خود را می سازد.
اعداد فارسی (۱۳۸۱/۲/۲۹)
توسط: مديريت سايت
ارائه يک راه حل ساده برای حل مشکل نمايش اعداد فارسی در متون و سايتهای فارسی که از يونيکد استفاده کرده اند.
ايران در جهانی سازی دات نت (۱۳۸۰/۱۲/۲۵)
توسط: اميد خندان راد
بررسی جهانی سازی در دات نت و نقش و موقعيت فعلی ايران در آن
بررسی کلاس Globalization.CultureInfo (۱۳۸۰/۱۲/۲۵)
توسط: اميد خندان راد
بررسی مشخصات کشور ايران در کلاس CultureInfo
تقويم هجری شمسی (جلالی) (۱۳۸۰/۱۲/۲۵)
توسط: اميد خندان راد
پيشنهاد وارد کردن تقويم هجری شمسی به پروژه دات نت
طرح بندی صفحات فارسی (۱۳۸۰/۱۲/۱۱)
توسط: مديريت سايت
مهمترين مبحث در طرح بندی و ساخت صفحات فارسی در HTML با استفاده از بکارگيری DIR در تعيين جهت متن
زبان فارسی در HTML (۱۳۸۰/۱۱/۲۷)
توسط: مديريت سايت
چگونگی ساخت صفحات HTML بصورت فارسی با تعيين مجموعه نويسه و زبان مورد استفاده
پشتيبانی استاندارد يونی‌کد (۱۳۸۰/۹/۲۹)
توسط: مديريت سايت
بررسی پشتيبانی بين اللملی سازی در محيط های مختلف
فناوری‌ها‌ی مرتبط با يونی‌کد (۱۳۸۰/۹/۲۹)
توسط: مديريت سايت
بررسی ارتباط فناوری‌های مختلف مانند HTML و XML با يونی‌کد

« بعدی ۲ ۱ قبلی »

بازگشت


IranASP.NET - فرم های وب

فرم های وب

فرم های وب يکی از اجزای مهم فناوری ASP.NET است که با استفاده از آنها می توان صفحات پيشرفته وب را به آسانی ايجاد نمود.

کنترل‌های پویا (۱۳۸۴/۳/۲)
توسط: سعد شمسایی
چگونگی اضافه کردن یک کنترل کاربری (User Control) در مواقع لازم با استفاده از متد LoadControl
صدا زدن رويدادهای User Control از داخل فرم‌های وب (۱۳۸۳/۱۲/۲۳)
توسط: Shahabfar.com Iranian .NET Community
استفاده از کنترل‌های کاربری يا User Control در ميان برنامه نويسان ASP.NET طرفداران زيادی دارد. با استفاده از UC می توان مجموعه ای از کنترلهای سمت سرور يا html را در جاهای مختلف از صفحات aspx يا داخل...
لذت برنامه نويسی تحت وب با ASP.NET 2.0: تغيير Master Page ها بصورت پويا (۱۳۸۳/۹/۹)
توسط: Shahabfar.com Iranian .NET Community
در قسمت اول از مجموعه اين مقاله ها آموختيد كه چگونه می توان بوسيله Master Page ها در ASP.NET 2.0 به سادگی طرح بندی های مختلفی را برای فرم های وب ايجاد كرد. تحت شرايطی بعضاً ممكن است به تغيير يك...
لذت برنامه نويسی تحت وب با ASP.NET 2.0: بكارگيری Master Page ها (۱۳۸۳/۸/۱۸)
توسط: Shahabfar.com Iranian .NET Community
ASP.NET 2.0 قابليت های جديدی را به همراه آورده است. يکی از مهمترين اين قابليتها اصطلاحا Master Page نام دارد. اين نوآوری شما را قادر می سازد تا به راحتی بتوانيد يک ظاهر واحد و يکسان برای کليه صفحات...
ايجاد يک کنترل - قسمت دوم (۱۳۸۳/۶/۳)
توسط: رضا قلعه
کنترل يک عنصر ويژوال می باشد که می توان آنرا در زمان طراحی برروی فرم قرار داد و در صورت لزوم خاصيت های آن را تغيير داد. اين مقاله به بررسی چگونگی ساخت يک کنترل برای WinForm می پردازد که با اندکی...
ايجاد يک کنترل - قسمت اول (۱۳۸۳/۵/۲۷)
توسط: رضا قلعه
کنترل يک عنصر ويژوال می باشد که می توان آنرا در زمان طراحی برروی فرم قرار داد و در صورت لزوم خاصيت های آن را تغيير داد. اين مقاله به بررسی چگونگی ساخت يک کنترل برای WinForm می پردازد که با اندکی...
چهار روش برای نمايش محتوای DataSet در فرمهای وب (۱۳۸۳/۳/۲۷)
توسط: احسان وليزاده
در ADO.NET دو روش برای کار با داده ها وجود دارد: DataSet و DataReader. هر کدام از اين دو روش موارد استفاده خود را دارند. اگر هدف نشان دادن سريع داده هاست DataReader مناسب تر از DataSet می باشد ولی...
افزودن یک ستون انتخاب به DataGrid (۱۳۸۲/۱۲/۱۹)
توسط: سلمان هوشمند
حتما ديده‎ايد که مثلا صندوق های پستی Hotmail و Yahoo به کاربران اجازه میدهند تا در لیست ایمیل های خود یک یا چند ایمیل را انتخاب کرده و عمل واحدی را روی آن انجام دهند. انتخاب هر ايميل با تيک زدن يک...
نمايش تصاوير در DataGrid (۱۳۸۲/۷/۲۴)
توسط: احسان وليزاده
آشنايی با کنترل DataGrid و قابليتهای آن با استفاده از مثالی جهت نمايش تصاوير در آن
انواع روشهای انتقال مقادير بين فرمهای وب ASP.NET (۱۳۸۲/۶/۲۹)
توسط: احسان وليزاده
در اين مقاله انواع روشهای مختلف موجود برای ارسال مقادير بين فرمهای وب ASP.NET بررسی می‌شوند.

« بعدی ۳ ۲ ۱ قبلی »

جستجو: بگرد!
جستجوی پيشرفته
نام کاربری |
کلمه عبور |


IranASP.NET - فرم های وب

فرم های وب

فرم های وب يکی از اجزای مهم فناوری ASP.NET است که با استفاده از آنها می توان صفحات پيشرفته وب را به آسانی ايجاد نمود.

آشنايی با کنترل DataList (۱۳۸۲/۶/۲)
توسط: ميلاد کرباسی زاده
نمايش داده های يک جدول از بانک اطلاعاتی در يک DataList
JavaScript و ASP.NET (۱۳۸۲/۳/۱۲)
توسط: مديريت سايت
اين مقاله به بررسی ارتباط ميان کدهای Server-Side و Client-Side پرداخته و نحوه برقراری اين ارتباط را با ذکر چند مثال کاربردی شرح می دهد.
ListBox با گزينه های رنگی در ASP.NET (۱۳۸۲/۱/۲۱)
توسط: مديريت سايت
در اين مقاله نحوه نوشتن يک listbox دلخواه با قابليت تعيين موارد Style برای گزينه های آن بصورت جداگانه ارائه شده است.
يک کنترل اعتبارسنجی دلخواه برای ListBox (۱۳۸۱/۱۲/۱۷)
توسط: مديريت سايت
نحوه ساخت يک کنترل اعتبارسنجی نمونه و دلخواه جهت انتخاب تعداد معينی گزينه از يک ListBox توسط کاربر.
ViewState و نگهداری مقادير فرمها - قسمت اول (۱۳۸۱/۱۰/۲۸)
توسط: علی رئيس دانا
در ASP کلاسيک بعد از تائيد يک فرم اطلاعات ورودی از بين می رود. برای رفع اين عيب در ASP.NET از ViewState استفاده می شود.
ViewState و نگهداری مقادير فرمها - قسمت دوم (۱۳۸۱/۱۰/۲۸)
توسط: مديريت سايت
در ASP کلاسيک بعد از تائيد يک فرم اطلاعات ورودی از بين می رود. برای رفع اين عيب در ASP.NET از ViewState استفاده می شود.
کنترلهای اعتبارسنجی در ASP.NET (۱۳۸۱/۱۰/۱۶)
توسط: مديريت سايت
در اين مقاله با نحوه اعتبارسنجی فرم های ورودی وب و نحوه بکارگيری کنترلهای مربوطه در ASP.NET آشنا می شويم.
آشنائی با کنترل AdRotator (۱۳۸۱/۸/۱۴)
توسط: سيد امين پوريه
با استفاده از كنترل AdRotator می توان آگهی های تبليغاتی را در يك سايت به صورت دلخواه نمايش داد.
کار کردن با کنترل DataGrid (۱۳۸۱/۳/۴)
توسط: عليرضا پورشاهيد
آشنائی با کنترل DataGrid جهت نمايش اطلاعات استخراج شده از بانک اطلاعاتی
رويدادها در فرم های وب (۱۳۸۱/۱/۲۲)
توسط: حامد بنايی
بررسی رويدادها در فرم های وب و نحوه رسيدگی به آنها و نشان دادن عکس العمل مناسب به کاربر

« بعدی ۳ ۲ ۱ قبلی »

جستجو: بگرد!
جستجوی پيشرفته
نام کاربری |
کلمه عبور |


IranASP.NET - فرم های وب

فرم های وب

فرم های وب يکی از اجزای مهم فناوری ASP.NET است که با استفاده از آنها می توان صفحات پيشرفته وب را به آسانی ايجاد نمود.

کنترل های موجود در فرم های وب (۱۳۸۱/۱/۲۱)
توسط: حامد بنايی
در دات نت به غير از کنترلهايی که می توانند توسط برنامه نويس ايجاد شوند، سه نوع کنترل ديگر با نام های HTML Server Control ، ASP.NET Server Control و Validation Control وجود دارد.
تشريح ساختمان فرم های وب (۱۳۸۱/۱/۲۰)
توسط: حامد بنايی
فرم وب در هر کدام از زبان های دات نت از يک بخش کد html و يک بخش کد به زبان مورد نظر تشکيل شده است.
مراحل مختلف اجرای يک فرم وب در ASP.NET (۱۳۸۱/۱/۲۰)
توسط: حامد بنايی
ASP.NET مانند ASP کلاسيک به شکل تفسيری اجرا نمی شود، بلکه کامپايل شده و هر بار فايل کامپايل شده با سرعت بالايی اجرا می شود.
آشنائی با فرم های وب (۱۳۸۱/۱/۱۸)
توسط: حامد بنايی
فرم های وب به عنوان يکی از مهمترين اجزای ASP.NET، جهت ايجاد فرم های ورود اطلاعات کاربر بکار می روند.
کنترل HyperLink يا پيوند (۱۳۸۰/۱۲/۵)
توسط: شاهو طوفانی
نشان دادن پيوند با استفاده از HyperLink وخصوصيات آن
الحاق يک ListBox به شئ ArrayList (۱۳۸۰/۱۲/۵)
توسط: شاهو طوفانی
اين مقاله نحوه تركيب و فراخوانی داده ها را از طريق شئ ArrayList نشان می دهد.
کنترل Label يا برچسب (۱۳۸۰/۱۱/۶)
توسط: مديريت سايت
نمايش متن يا برچسب با استفاده از کنترل Label و تعيين رنگ، فونت و ساير مشخصات آن
رسيدگی به رويدادهای کنترلی در ASP.NET (۱۳۸۰/۱۰/۸)
توسط: مديريت سايت
نحوه پاسخگوئی به اعمال يا درخواستهای کاربر در يک صفحه ASP.NET
کنترل های وب در ASP.NET (۱۳۸۰/۱۰/۱)
توسط: مديريت سايت
دريافت اطلاعات از ورودی و بررسی کنترل های وب در ASP.NET
کنترل های HTML (۱۳۸۰/۹/۲۴)
توسط: مديريت سايت
دريافت اطلاعات ورودی و بررسی کنترل های HTML در ASP.NET

« بعدی ۳ ۲ ۱ قبلی »

جستجو: بگرد!
جستجوی پيشرفته
نام کاربری |
کلمه عبور |


IranASP.NET - ASP کلاسيک

ASP کلاسيک

ASP مخفف Active Server Pages است که در مقابل ASP.NET که نسل بعدی آن است، اصطلاحا ASP کلاسيک ناميده می شود. ASP روشی کارا و آسان جهت توليد سايتهای پويای وب و برنامه های تحت وب می باشد.

کنترلهای مخفی (۱۳۸۱/۱۱/۷)
توسط: سيد محمد سعيد موسوی
اين مقاله به بررسی کنترلهای مخفی يا hidden در فرم ها پرداخته و کاربرد آن را شرح می دهد.
Mehdi Smart Navigation (۱۳۸۱/۸/۸)
توسط: مهدی ميرزايی
در اين مقاله آقای مهدی ميرزائی سعی کرده است تا با ارائه توضيحات کافی و متن برنامه، امکان Smart Navigation موجود در ASP.NET را در ASP کلاسيک شبيه سازی نمايد.
تبديل تاريخ و ساعت محلی به تاريخ و ساعت رسمی ايران (۱۳۸۱/۷/۱)
توسط: محمود مروج
اين مقاله به ارايه يک راه حل مفيد برای تبديل تاريخ ميلادی به شمسی با توجه به اختلاف زمانی می پردازد.
سيستم پرداخت Authorize.Net (۱۳۸۱/۵/۱۳)
توسط: مهدی ميرزايی
استفاده نمودن از ASP يا ASP.Net و XMLHTTP برای برقراری ارتباط با Authorize.Net
ورود اطلاعات فارسی با استفاده از جاوااسکريپت (۱۳۸۱/۴/۲۴)
توسط: رحمان حق پرست
در اين مقاله به نحوه ورود اطلاعات فارسی از طريق فرمهای HTML با استفاده از يک تابع جاوااسکريپت در کار با Access و ASP پرداخته شده است.
HTTP HEADERS (۱۳۸۱/۳/۲۳)
توسط: پيمان هوشمندی راد
آشنائی با هدرهای HTTP و نوع اطلاعات همراه و نحوه بدست آوردن آنها
معرفی ADO و کاربرد آن در ASP (بخش دوم – مثال) (۱۳۸۱/۲/۵)
توسط: محمد جواد سخائی
در اين مقاله کاربرد عملی ADO در قالب چند مثال عملی در مورد حذف، اضافه و تغيير در يک بانک اطلاعاتی نمونه تبيين شده است.
معرفی ADO و کاربرد آن در ASP (بخش اول – مفاهيم) (۱۳۸۱/۲/۲)
توسط: محمد جواد سخائی
در اين مقاله ADO و نحوه استفاده از اشياء آن در صفحات ASP برای ارتباط با بانك های اطلاعاتی تشريح شده و برخی از اشياء و متدهای مربوطه آنها تبين خواهد شد.
راهكارهائی برای بهبود طراحی صفحات ASP – بخش سوم (۱۳۸۱/۱/۲۷)
توسط: محمد جواد سخائی
در اين مقاله سعی می شود كه با ارائه يك ديدگاه مهندسی نرم افزار و تاكيد بر نحوه استفاده از كلاس ها، اقدام به طراحی صفحات ASP نمود.
تبديل تاريخ ميلادی به شمسی (۱۳۸۱/۱/۲۵)
توسط: حميد استادهاشمی
تبديل تاريخ ميلادی به شمسی

« بعدی ۴ ۳ ۲ ۱ قبلی »

جستجو: بگرد!
جستجوی پيشرفته
نام کاربری |
کلمه عبور |


IranASP.NET - ASP کلاسيک

ASP کلاسيک

ASP مخفف Active Server Pages است که در مقابل ASP.NET که نسل بعدی آن است، اصطلاحا ASP کلاسيک ناميده می شود. ASP روشی کارا و آسان جهت توليد سايتهای پويای وب و برنامه های تحت وب می باشد.

کوکی در ASP کلاسيک (۱۳۸۱/۱/۲۴)
توسط: مسلم ابراهيمی
آشنائی با کوکی ها و روش استفاده آنها در ASP کلاسيک
ايجاد يك سيستم كلمه عبور ساده – قسمت ۱ (۱۳۸۰/۱۲/۲۲)
توسط: حميد استادهاشمی
ايجا يك سيستم Login برای ورود اعضاء يك سايت
ايجاد يك سيستم كلمه عبور ساده – قسمت ۲ (۱۳۸۰/۱۲/۲۲)
توسط: حميد استادهاشمی
ايجاد يك سيستم Login برای ورود اعضاء يك سايت
اجرای ASP روی كامپيوتر خودتان (۱۳۸۰/۱۲/۱۶)
توسط: مسلم ابراهيمی
در اين مقاله برای مبتديان روش اجرای ASP و برنامه های مورد نياز توضيح داده شده است.
راهكارهائی برای بهبود طراحی صفحات ASP – بخش دوم (۱۳۸۰/۱۲/۱۴)
توسط: محمد جواد سخائی
در اين مقاله سعی می شود كه با ارائه يك ديدگاه مهندسی نرم افزار و با استفاده از دستورات Server.Execute و Server.Transfer اقدام به طراحی صفحات ASP نمود.
آشنايی با فايل Global.asa (۱۳۸۰/۱۲/۱)
توسط: محمد جواد سخائی
نحوه بکارگيری فايل Global.asa و کاربردهای آن در يک برنامه ASP کلاسيک
بررسی شئ Application (۱۳۸۰/۱۱/۱۶)
توسط: حميد استادهاشمی
بررسی مجموعه ها، متدها و رويدادهای شئ Application در ASP كلاسيك
ارتباط ASP با بانكهای اطلاعاتی (۱۳۸۰/۱۱/۱۶)
توسط: حميد استادهاشمی
بررسی SQL و ADO و نحوه برقراری ارتباط بين آنها و ASP
راهكارهائی برای بهبود طراحی صفحات ASP – بخش اول (۱۳۸۰/۱۱/۱۵)
توسط: محمد جواد سخائی
در اين مقاله سعی می شود كه با ارائه يك ديدگاه مهندسی نرم افزار و با استفاده از امکان فايلهای ضميمه يا SSI اقدام به طراحی صفحات ASP نمود.
ايجاد شمارنده برای كاربران فعال در يك صفحه (۱۳۸۰/۱۰/۲۷)
توسط: حميد استادهاشمی
طريقه ايجاد يك شمارنده برای شمارش تعداد كابران فعال در صفحه بوسيله فايل global.asa

« بعدی ۴ ۳ ۲ ۱ قبلی »

جستجو: بگرد!
جستجوی پيشرفته
نام کاربری |
کلمه عبور |


IranASP.NET - ASP کلاسيک

ASP کلاسيک

ASP مخفف Active Server Pages است که در مقابل ASP.NET که نسل بعدی آن است، اصطلاحا ASP کلاسيک ناميده می شود. ASP روشی کارا و آسان جهت توليد سايتهای پويای وب و برنامه های تحت وب می باشد.

شئ ها در ASP (۱۳۸۰/۱۰/۱۳)
توسط: حميد استادهاشمی
بررسى اشياء موجود در ASP 3.0 به همراه شرح هر شئ
درس دهم: تعداد مراجعه به يك صفحه وب (۱۳۸۰/۱۰/۴)
توسط: محمد جواد سخائی
کار با فايل ها از طريق نحوه محاسبه تعداد دفعات مراجعه به يك صفحه وب
درس يازدهم: تشخيص مشخصات کاربر (۱۳۸۰/۱۰/۴)
توسط: محمد جواد سخائی
تشخيص نوع مرورگر، سيستم عامل و IP كاربران اينترنت و ساير اطلاعات مرتبط
درس نهم: مفهوم کاربردی برنامه در ASP کلاسيک (۱۳۸۰/۹/۲۰)
توسط: محمد جواد سخائی
آشنائی با شئ های Application و Session و کاربرد آنها
درس هفتم: آشنائی با شئ Session (۱۳۸۰/۹/۱۷)
توسط: محمد جواد سخائی
کاربرد شئ Session و نحوه تعريف و بکارگيری متغير در آن
درس هشتم: آشنائی با شئ Application (۱۳۸۰/۹/۱۷)
توسط: محمد جواد سخائی
کاربرد شئ Application و نحوه تعريف و بکارگيری متغير در آن
توضيح در برنامه (۱۳۸۰/۹/۱۱)
توسط: مديريت سايت
استفاده از توضيحات در برنامه
درس ششم: کوکی ها در ASP (۱۳۸۰/۹/۱۱)
توسط: محمد جواد سخائی
آشنايی با کوکی ها و نحوه بکارگيری آنها
درس پنجم: فرم ها در ASP - قسمت دوم (۱۳۸۰/۹/۸)
توسط: محمد جواد سخائی
دريافت اطلاعات از ورودی بوسيله فرم ها
درس پنجم: فرم ها در ASP - قسمت اول (۱۳۸۰/۹/۵)
توسط: محمد جواد سخائی
دريافت اطلاعات از ورودی بوسيله فرم ها

« بعدی ۴ ۳ ۲ ۱ قبلی »

جستجو: بگرد!
جستجوی پيشرفته
نام کاربری |
کلمه عبور |


IranASP.NET - ASP کلاسيک

ASP کلاسيک

ASP مخفف Active Server Pages است که در مقابل ASP.NET که نسل بعدی آن است، اصطلاحا ASP کلاسيک ناميده می شود. ASP روشی کارا و آسان جهت توليد سايتهای پويای وب و برنامه های تحت وب می باشد.

درس چهارم: روال ها و توابع در ASP (۱۳۸۰/۹/۳)
توسط: محمد جواد سخائی
بررسی روال ها و زيربرنامه ها در ASP کلاسيک
درس اول: آشنائی اوليه با تكنولوژی ASP (۱۳۸۰/۸/۱۷)
توسط: محمد جواد سخائی
معرفی فناوری ASP و بستر مورد نياز آن
درس دوم: بررسی ساختار و دستور زبان ASP (۱۳۸۰/۸/۱۷)
توسط: محمد جواد سخائی
آشنائی با ساختار برنامه در ASP بهمراه چند مثال
درس سوم: بررسی متغيرها در ASP (۱۳۸۰/۸/۱۷)
توسط: محمد جواد سخائی
نحوه تعريف متغير و بکارگيری آن در ASP
معرفی اوليه تكنولوژی ASP (۱۳۸۰/۸/۸)
توسط: محمد جواد سخائی
معرفی فناوری ASP و تاريخچه آن بهمراه قابليت و لوازم شروع آن
ويژگی های تكنولوژی ASP (۱۳۸۰/۸/۸)
توسط: محمد جواد سخائی
معرفی ويژگی ها و قابليت های تكنولوژی ASP
ASP چگونه کار می کند؟ (۱۳۸۰/۸/۳)
توسط: مديريت سايت
آشنائی با روش کار صفحات ASP و مقايسه آن با HTML به همراه مثال
مقدمه ای بر ASP (۱۳۸۰/۸/۲)
توسط: مديريت سايت
نقطه شروع کار با ASP شامل معرفی، کاربرد و مزايای ASP

« بعدی ۴ ۳ ۲ ۱ قبلی »

جستجو: بگرد!
جستجوی پيشرفته
نام کاربری |
کلمه عبور |


IranASP.NET - آشنايی با #C

آشنايی با #C

شامل مقالاتی در مورد آموزش و قابليتهای زبان برنامه نويسی #C.

شئ گرايی در #C (۱۳۸۳/۳/۱۸)
توسط: جعفر حيدری
دنيای برنامه نويسی امروزه بر مفهوم شئ گرايی استوار است. شئ گرايی به زبان ساده يعنی دنيا را آنطور ببنيم که هست! زبان #C يکی از بهترين زبانهايی است که دارای تمامی امکانات جهت پياده سازی مفاهيم اصيل شئ...
آشنائی با زبان #C (۱۳۸۱/۲/۲۴)
توسط: محمد جواد سخائی
در اين مقاله سعی می شود كه با بررسی برخی از ويژگی های زبان #C، ضرورت های فراگيری آن، توضيح داده شود.

جستجو: بگرد!
جستجوی پيشرفته
نام کاربری |
کلمه عبور |


IranASP.NET - کليات ASP.NET

کليات ASP.NET

مقالاتی جهت آشنائی با ASP.NET و مجموعه دات نت و شناخت ويژگيها و توانمنديهای آن و ساير موارد مربوطه.

خداحافظ IranASP.NET! (۱۳۸۴/۷/۶)
توسط: مديريت سايت
داشتم می‌رفتم ديدم بدون خداحافظی بی معرفتی است. با "مقاله" شروع کردم، با "مقاله" هم به پايان می‌برم. اگر دنبال مطلب فنی هستيد، اين مقاله آخر را نخوانيد. اگر می‌خواهيد بدانيد که چرا می‌روم، اين گفتار...
کوکی ها در ASP.NET (۱۳۸۴/۴/۷)
توسط: محمد علويان
اين مقاله توضيح می دهد که چگونه می توان کوکی‌ها را با استفاده از ASP.NET ساخت، خواند و يا حذف کرد.
دستکاری تصاویر در ASP.NET (۱۳۸۴/۱/۲۴)
توسط: حسین روزنامه چی
در دات نت همیشه کارهای بزرگ را می توان با چند خط کوتاه، برنامه‌ی ساده انجام داد. یکی از این کارها ترسیم و دستکاری تصاویر است.
جلوگيری از دزدیده شدن محتویات وب سایت (۱۳۸۴/۱/۱۵)
توسط: Amin Roudaky
موضوع اين مقاله کلیه فایلهای موجود در سایت از قبیل JPG ،DOC ،PDF... می‌باشد. اگر از فایلهای خود محافظت نکنید به راحتی هر کسی میتواند به آنها دسترسی پیدا کند چون فقط کافیست از URL آن مطلع شود تا به...
جستجوی نام های دامنه (Whois) در ASP.NET (۱۳۸۳/۱۲/۳)
توسط: احسان صادقی
اگر به سایتهای ثبت دامنه مانند www.Register.com سر زده باشید، دیده اید که این سایتها امکاناتی برای جستجوی نام دامنه در اختیار شما می گذارند که به شما وجود یا عدم وجود آن نام را اطلاع می دهند و...
به رمز درآوردن اطلاعات (۱۳۸۳/۹/۲۲)
توسط: حسین روزنامه چی
تا به حال به این فکر افتاده اید که یک سری اطلاعات را به صورت رمز در آورید و از دید کاربر پنهان کنید؟ برای مثال یک QueryString یا اطلاعات ذخیره شده داخل یک کوکی. گاهی هم بد نیست بعضی از اطلاعات داخل...
بررسی خطاها در ASP.NET - قسمت دوم (۱۳۸۳/۸/۱۰)
توسط: نسرین قاسمپورملکی
هنگامی که در یک صفحه ASP.NET خطایی رخ می دهد، ASP.NET اطلاعاتی راجع به خطا به Client می فرستد. در اين مقاله به بررسی سفارشی کردن صفحات خطا، بررسی خطاها بوسیله برنامه نویسی و نوشتن خطاها در Event Log...
بررسی خطاها در ASP.NET - قسمت اول (۱۳۸۳/۷/۲۵)
توسط: نسرین قاسمپورملکی
هنگامی که در یک صفحه ASP.NET خطایی رخ می دهد، ASP.NET اطلاعاتی راجع به خطا به Client می فرستد. در اين مقاله به نحوه راه اندازی و اعلام خطاها به کاربر،نمایش یا عدم نمایش خطاها برای کاربران، سفارشی...
بهترين راه يادگيری ASP.NET (۱۳۸۳/۶/۳۱)
توسط: مديريت سايت
همواره ايميل های زيادی بدستم رسيده است که می پرسند: بهترين راه يادگيری ASP.NET چيست؟ يا اينکه برای يادگيری ASP.NET از کجا بايد شروع کنيم؟ و سوالاتی از اين قبيل. در اين مقاله سعی کرده ام که تجربيات...
کوچ از ASP.NET 1.x به ASP.NET 2.0 - قسمت دوم (۱۳۸۳/۶/۲۵)
توسط: کيوان نيّری
نسل اول ASP.NET در قالب نسخه‎های 1.0 و 1.1 ارائه گشت. گذشت زمان و کسب تجربيات متعدد، پيدايش نيازهای جديد، ضعف های موجود و نيز به دليل ايجاد راه حل‎های تکراری ولی پرکاربرد توسط برنامه نويسان جهت حل...

« بعدی ۷ ۶ ۵ ۴ ۳ ۲ ۱ قبلی »

جستجو: بگرد!
جستجوی پيشرفته
نام کاربری |
کلمه عبور |


IranASP.NET - کليات ASP.NET

کليات ASP.NET

مقالاتی جهت آشنائی با ASP.NET و مجموعه دات نت و شناخت ويژگيها و توانمنديهای آن و ساير موارد مربوطه.

کوچ از ASP.NET 1.x به ASP.NET 2.0 - قسمت اول (۱۳۸۳/۶/۱۱)
توسط: کيوان نيّری
نسل اول ASP.NET در قالب نسخه‎های 1.0 و 1.1 ارائه گشت. گذشت زمان و کسب تجربيات متعدد، پيدايش نيازهای جديد، ضعف های موجود و نيز به دليل ايجاد راه حل‎های تکراری ولی پرکاربرد توسط برنامه نويسان جهت حل...
ساخت يک خروجی RSS برای سايت شما (۱۳۸۳/۵/۱۸)
توسط: حامد سعیدی فرد
RSS يک راه استاندارد برای به اشتراک گذاشتن محتوای سايت ها با ديگران است. RSS يا همان Really Simple Syndication چيزی نيست به جز يک نشانه گذاری استاندارد شده XML که محتوايی که قصد به اشتراک گذاشتن آن...
کاهش حجم خروجی در ASP.NET (۱۳۸۳/۵/۵)
توسط: کيوان نيّری
مساله سرعت بارگذاری صفحات چه به صورت ايستا طراحی شده باشند و چه به صورت پويا از مباحث مهم در طراحی حرفه ای صفحات وب است اين مساله در کشور ما با توجه به سرعت نسبتا پايين خطوط اينترنت اهميت مضاعفی می...
مديريت نقش ها با استفاده از Generic Principle و FormsAuthentication (۱۳۸۳/۴/۹)
توسط: بهنام يوسفی شمالی
مديريت در سايت های دارای بخش کاربران و کلا سايت هايی که به نوعی احتياج به طبقه بندی دسترسی ها به بخش های مختلف سايت دارند، با اين بحث آشنا هستند.در اين مقاله به شکل عملی به شرح نحوه ی استفاده از...
چند زبانی در NET. (۱۳۸۳/۳/۱۰)
توسط: لطفعلی خوش نفس
يکی از برتری‎های NET. نسبت به رقيب اين است که شما می توانيد از چندين زبان برنامه نويسی در يک برنامه استفاده نمائيد. حسن اين قابليت حداقل در اين است که افراد تيم برنامه نويسی شما مجبور نيستند که همگی...
چگونگی ساخت Setup برای برنامه های NET. كه از Crystal Report استفاده می کنند (۱۳۸۳/۲/۳۱)
توسط: لطفعلی خوش نفس
برنامه نويسان حرفه ای معمولاً بعد از توليد برنامه‎ی خود، با استفاده از امکانات موجود در Visual Studio .NET برای آن يک Setup يا اصطلاحاً يک برنامه‎ی نصّاب می سازند. اما اگر برنامه شما جهت گزارشگيری از...
توليد صفحات استاتيک به کمک XML و ASP.NET (بخش دوم) (۱۳۸۳/۲/۲۳)
توسط: بهروز نوعی پور
شايد برای شما جالب باشد که بدانيد سايت هايی بزرگی چون CNN يا news.com چگونه صفحات خود را توليد می کنند و اينکه چرا پسوند صفحات آنها مثلا بجای asp يا aspx يا php وغيره، html است؟ اين مقاله را بخوانيد...
توليد صفحات استاتيک به کمک XML و ASP.NET (بخش اول) (۱۳۸۳/۲/۱۷)
توسط: بهروز نوعی پور
شايد برای شما جالب باشد که بدانيد سايت هايی بزرگی چون CNN يا news.com چگونه صفحات خود را توليد می کنند و اينکه چرا پسوند صفحات آنها مثلا بجای asp يا aspx يا php وغيره، html است؟ اين مقاله را بخوانيد...
صفحه نوردی در ASP.NET (۱۳۸۳/۱/۳۰)
توسط: مديريت سايت
حتما تاکنون بعنوان يک برنامه نويس وب به مقوله گزارشگيری برخورد نموده ايد. مثلا از شما خواسته اند که ليست فلان اقلام داده ای مانند ليست کالا، ليست سفارشات و... را تهيه کنيد. در بسيار از موارد اگر...
تاييد و شناسايی کاربران بر اساس فرمهای وب در برنامه‎های ASP.NET (۱۳۸۳/۱/۱۶)
توسط: احسان وليزاده
برنامه‎های وب ASP.NET می توانند از سه روش مختلف برای شناسائی و تاييد کاربران وب سايت استفاده کنند. اين روش ها عبارتند از: Windows Authentication ، Forms-Based Authentication و Passport Authentication...

« بعدی ۷ ۶ ۵ ۴ ۳ ۲ ۱ قبلی »

جستجو: بگرد!
جستجوی پيشرفته
نام کاربری |
کلمه عبور |


IranASP.NET - کليات ASP.NET

کليات ASP.NET

مقالاتی جهت آشنائی با ASP.NET و مجموعه دات نت و شناخت ويژگيها و توانمنديهای آن و ساير موارد مربوطه.

IrMail، روشی جديد برای ارسال نامه در ASP.NET (بخش دوم) (۱۳۸۲/۱۲/۱۳)
توسط: محمود مروج
ارسال نامه از طريق سايت بصورت خودکار همواره برای برنامه نويسان وب موضوعی حساس و مهم بوده است. بسياری از بخش های يک سايت حرفه‎ای مانند صفحه ارتباط با مدير سايت، نامه‎های يادآوری کلمه رمز کاربران،...
IrMail، روشی جديد برای ارسال نامه در ASP.NET (بخش اول) (۱۳۸۲/۱۲/۴)
توسط: محمود مروج
ارسال نامه از طريق سايت بصورت خودکار همواره برای برنامه نويسان وب موضوعی حساس و مهم بوده است. بسياری از بخش های يک سايت حرفه‎ای مانند صفحه ارتباط با مدير سايت، نامه‎های يادآوری کلمه رمز کاربران،...
فايل Web.Config را بهتر بشناسيم (۱۳۸۲/۱۱/۱۹)
توسط: کيوان نيّری
بيشتر برنامه‎های کامپيوتری تنظيمات خاص خود را در قالب مفهومی بنام Setup نگهداری می‎کنند. برنامه‎های ASP.NET هم از اين قاعده مستثنی نيستند و می‎توان کليه تنظيمات وب سايت را در قالب يک فايل از جنس XML...
کارکردن با رشته‌ها و متن‌ها در ASP.NET (۱۳۸۲/۱۰/۲۷)
توسط: رسول هاجری
اغلب متن‎هايی که کاربران يک سايت توسط فرم‌ها ارسال می‌کنند و يا اطلاعاتی که از يک بانک دريافت می‌شود، نياز به بررسی و يا اعمال تغييرات دارند. در اين مقاله با برخی توابع و امکانات ASP.NET برای کارکردن...
آمار کاربران سايت در ASP.NET (۱۳۸۲/۱۰/۸)
توسط: رسول هاجری
روزانه کاربران زيادی از سايت شما بازديد می کنند و برای هر مدير سايت آمار بازديدها، صفحات بازديد شده، ساعت و تاریخ بازديد، لينک و سايتی که کاربر به واسطه آن از سايت ما بازديد نموده است و . . . از...
Session State در ASP.NET (۱۳۸۲/۹/۳)
توسط: احسان وليزاده
در این مقاله شئ Session در ASP.NET بررسی می شود.
نگاهی به ASP.NET Whidbey (۱۳۸۲/۸/۷)
توسط: مديريت سايت
نگاه مختصری به نسخه جديد ASP.NET به نام Whidbey و بررسی قابليتهای آن
مقایسه نحوی ۴ زبان حاضر در ویژوال استودیو 2003 (۱۳۸۲/۷/۸)
توسط: حسین پناهی
در این مقاله به بررسی و مقایسه اجمالی ۴ زبان J#.NET ،C++.NET ،VB.NET و C#.NET پرداخته میشود که این مقایسات به کمک مثال بیان میشود. این مقاله برای افرادی که قصد آموختن یکی از این زبانها را دارند بسیار...
تشخيص هويت و تعيين اعتبار در ASP.NET (۱۳۸۲/۷/۶)
توسط: محمد نظارت
از موقعی که يک درخواست به وب سرور برای يک فايل که توسط ASP.NET سرويس داده می شود دريافت می گردد و تا موقعی که پاسخ درخواست به کاربر فرستاده می شود يک سری مراحل تشخيص هويت و تعيين اعتبار توسط IIS و...
گرافيک در ASP.NET (۱۳۸۲/۶/۲۲)
توسط: مجتبی کيانی
آموزش چگونگی رسم تصاوير بصورت پويا در ASP.NET

« بعدی ۷ ۶ ۵ ۴ ۳ ۲ ۱ قبلی »

جستجو: بگرد!
جستجوی پيشرفته
نام کاربری |
کلمه عبور |


IranASP.NET - کليات ASP.NET

کليات ASP.NET

مقالاتی جهت آشنائی با ASP.NET و مجموعه دات نت و شناخت ويژگيها و توانمنديهای آن و ساير موارد مربوطه.

XML و خواندن اطلاعات از آن (۱۳۸۲/۵/۲۲)
توسط: علی حاج شفيعيها
روش تبديل اطلاعات از بانک اطلاعاتی به XML و نمايش اطلاعات آن
استخراج داده از XML در ASP.NET (۱۳۸۲/۵/۱۶)
توسط: بهنام يوسفی شمالی
در اين مقاله با يکی از روشهای ساده استخراج داده از XML به عنوان منبع برای داده های کوچک آشنا می شويم.
ساختار يک صفحه ASP.NET (۱۳۸۲/۴/۱۷)
توسط: احسان پگاه
در اين مقاله به زبانی ساده با قسمتهای تشکيل دهنده يک صفحه ASP.NET آشنا می شويم.
Threadها در ASP.NET (۱۳۸۲/۲/۱۰)
توسط: محمود مروج
در اين مقاله سعی شده است مفهوم Threading و ارتباط آن با ASP.NET و مفهوم Application Domain بيان گردد.
۱۰ دليل مهم جهت ارتقاء به Visual Studio .NET 2003 (۱۳۸۲/۲/۲)
توسط: مديريت سايت
Visual Studio .NET 2003 نسبت به نسخه قبلی خود دارای امکانات و قابليتهای بيشتری می باشد که امر توليد انواع برنامه و سيستم ها را ارتقاء بخشيده است.
تازه های NET Framework 1.1. (۱۳۸۲/۱/۲۳)
توسط: مديريت سايت
دات نت نسخه 1.1، توانسته است نسخه قبلی را با ارائه قابليتهای جديد، بهبود موارد موجود و افزايش حجم و کيفيت مستندات، توسعه دهد.
ايجاد قالب برای صفحات وب در ASP.NET (۱۳۸۱/۱۱/۲۶)
توسط: محمود مروج
در اين مقاله به بررسی روش های ايجاد قالب (template) برای صفحات وب پرداخته می شود.
ارسال نامه در ASP.NET از نگاهی ديگر (۱۳۸۱/۱۱/۱۹)
توسط: مديريت سايت
نحوه ارسال نامه در ASP.NET با امکانات و تنظيمات بيشتر با استفاده از CDOSYS.
انتقال مقادير بين صفحات يک برنامه (۱۳۸۱/۹/۳)
توسط: مديريت سايت
در اين مقاله با يک روش جديد و مختص ASP.NET بنام Context جهت تبادل مقادير ميان صفحات يک برنامه آشنا می شويد.
Caching در ASP.NET (۱۳۸۱/۸/۲۱)
توسط: مديريت سايت
بررسی مساله Caching در ASP.NET از طريق معرفی انواع آن که عبارتند از Fragment Caching ،Page Output Caching و Data Caching.

« بعدی ۷ ۶ ۵ ۴ ۳ ۲ ۱ قبلی »

جستجو: بگرد!
جستجوی پيشرفته
نام کاربری |
کلمه عبور |


IranASP.NET - کليات ASP.NET

کليات ASP.NET

مقالاتی جهت آشنائی با ASP.NET و مجموعه دات نت و شناخت ويژگيها و توانمنديهای آن و ساير موارد مربوطه.

upload کردن فايل به سرور در ASP.NET (۱۳۸۱/۷/۲۹)
توسط: محمود مروج
اين مقاله به چگونگی upload کردن فايل به سرور در ASP.NET می پردازد.
Namespace چيست؟ (۱۳۸۱/۷/۱۶)
توسط: مديريت سايت
ارائه تعريف و مفهوم Namespace با اشاره به namespaceهای موجود در چارچوب دات نت و نحوه بکارگيری و تعريف آنها در برنامه.
codebehind چيست؟ (۱۳۸۱/۷/۲)
توسط: مديريت سايت
بررسی مفهوم codebehind و مزايا و نحوه بکارگيری و پياده سازی آن به سه روش مختلف
معماری فايل ASP.NET (۱۳۸۱/۶/۲۶)
توسط: مديريت سايت
آشنايی با انواع فايل و پسوندهای آنها در برنامه های کاربردی ASP.NET.
Smart Navigation چيست؟ (۱۳۸۱/۶/۱۲)
توسط: محمود مروج
اين مقاله به توضيح مفهوم smart navigation(هدايت هوشمندانه!) و چگونگى استفاده از آن مى پردازد.
ارسال نامه در ASP.NET (۱۳۸۱/۵/۱)
توسط: عليرضا پورشاهيد
در اين مقاله ياد خواهيم گرفت که چگونه می توان از طريق يک صفحه ASP.NET يک Email فرستاد.
ويژگی های امنيتی ASP.NET (۱۳۸۱/۴/۱۰)
توسط: مهدی ميرزايی
بررسی مختصر مساله امنيت در برنامه های ASP.NET در نحوه ارتباط آن با کاربر
نکاتی جهت بهينه سازی برنامه های ASP.NET (۱۳۸۱/۴/۱)
توسط: مديريت سايت
در اين مقاله با نکاتی آشنا می شويد که جهت بهينه سازی و افزايش کارآيی و سرعت برنامه های ASP.NET لازم می باشند.
Caching در ASP.NET (۱۳۸۱/۳/۱۹)
توسط: محمود مروج
آشنائی با مفهوم Caching و نحوه استفاده و بکارگيری آن در صفحات ASP.NET
جايگاه ASP.NET در مقايسه صفحات ايستا و پويا (۱۳۸۱/۲/۱۱)
توسط: محمد جواد سخائی
بررسی مفهومی صفحات وب ايستا و پويا و بررسی روش های تزريق اين پويائی از جايگاه سرويس دهنده و سرويس گيرنده بهمراه بررسی فناوريهای متدوال در اين خصوص با اشاره به ASP.NET

« بعدی ۷ ۶ ۵ ۴ ۳ ۲ ۱ قبلی »

جستجو: بگرد!
جستجوی پيشرفته
نام کاربری |
کلمه عبور |


IranASP.NET - کليات ASP.NET

۱۳۸۴ شنبه ۱۶ مهر صفحه اول | مقالات | خبرها | درباره | آگهی در سايت | ارتباط با ما
کليات ASP.NET

مقالاتی جهت آشنائی با ASP.NET و مجموعه دات نت و شناخت ويژگيها و توانمنديهای آن و ساير موارد مربوطه.

اصول پياده سازی نرم افزارهای مبتنی بر وب (۱۳۸۱/۲/۸)
توسط: محمد جواد سخائی
در اين مقاله تاريخچه و اصول پياده سازی نرم افزار بخصوص بر روی بستر وب تشريح شده است.
فرستادن Email از طريق ASP.NET (۱۳۸۱/۱/۱۵)
توسط: شاهو طوفانی
در اين مقاله نحوه فرستادن Email از يک صفحه ASP.NET نشان داده شده است.
پردازش های مبتنی بر Client Server (۱۳۸۰/۱۲/۱۴)
توسط: محمد جواد سخائی
بررسی معماری Client/Server در مدلهای تک لايه، دو لايه، سه لايه و چند لايه و اصول طراح معماری برنامه های تحت وب
بررسی CLR (۱۳۸۰/۱۲/۶)
توسط: حامد بنايی
بررسی و آشنائی با محيط زمان اجرای دات نت يعنی CLR و ويژگيهای آن از جهت انتقال برنامه ها، بحث نسخه و مديريت حافظه
مروری بر ساختار برنامه های NET. (۱۳۸۰/۱۲/۶)
توسط: حامد بنايی
هر برنامه ای که بر مبنای دات نت تعريف می شود از سه قسمت مهم و اصلی تشکيل شده است: اسمبلی، ماژول و تايپ.
ويژگيهای دات نت (۱۳۸۰/۱۲/۲)
توسط: حامد بنايی
آشنائی با مايکروسافت دات نت و شناخت قابليتها و بررسی ويژگيهای آن
چرا به دات نت احتياج داريم؟ (۱۳۸۰/۱۱/۲۱)
توسط: حامد بنايی
آشنائی با دات نت و بررسی مشکلاتی که حل آنها سبب تولد دات نت گرديد.
نشان دادن قابليتهای مرورگر در ASP.NET (۱۳۸۰/۱۱/۲۰)
توسط: شاهو طوفانی
اين مقاله نحوه نشان دادن قابليتهای مرورگر با استفاده از ASP.NET را نشان می دهد.
رويدادهای يک صفحه ASP.NET (۱۳۸۰/۱۰/۲۹)
توسط: مديريت سايت
بررسی مجموعه رويدادهايی که هنگام فراخوانی يک صفحه ASP.NET روی می دهند مانند Init و Load...
يک صفحه ASP.NET ساده (۱۳۸۰/۸/۳)
توسط: مديريت سايت
اولين برنامه در ASP.NET و شرح قسمتهای آن

« بعدی ۷ ۶ ۵ ۴ ۳ ۲ ۱ قبلی »

جستجو: بگرد!
جستجوی پيشرفته
نام کاربری |
کلمه عبور |


IranASP.NET - کليات ASP.NET

۱۳۸۴ شنبه ۱۶ مهر صفحه اول | مقالات | خبرها | درباره | آگهی در سايت | ارتباط با ما
کليات ASP.NET

مقالاتی جهت آشنائی با ASP.NET و مجموعه دات نت و شناخت ويژگيها و توانمنديهای آن و ساير موارد مربوطه.

ASP.NET چيست؟ (۱۳۸۰/۸/۲)
توسط: مديريت سايت
آشنائی با ASP.NET و بررسی ويژگيهای آن در مقايسه با ASP کلاسيک
مقدمه ای بر Microsoft.NET (۱۳۸۰/۸/۱)
توسط: مديريت سايت
معرفی فناوری NET . و بررسی قسمتهای اصلی آن

« بعدی ۷ ۶ ۵ ۴ ۳ ۲ ۱ قبلی »

جستجو: بگرد!
جستجوی پيشرفته
نام کاربری |
کلمه عبور |


IranASP.NET - آشنايی با VB.NET

آشنايی با VB.NET

مقالاتی جهت آشنايی و فراگيری زبان ويژوال بيسيک دات نت شامل نحوه تعريف متغير،عملگرها، ساختارهای شرطی، توابع و ساير مواردی که برای يادگيری يک زبان مورد نياز است.

برنامه نویسی شئ گرا در VB.NET (قسمت اول) (۱۳۸۴/۴/۲۳)
توسط: کامیار راستا
امروزه برنامه‌های کاربردی بر پایه شئ‌گرایی استوارند. تکنولوژی NET. امکانات بسیار جالب و کاملی در این زمینه دارد این مقاله که از کتاب ارزشمند Developing windows-based applications with microsoft VB...
آشنايی با Visual Basic.NET- متغيرها (۱۳۸۱/۶/۱۹)
توسط: مديريت سايت
آشنائی با مفهوم متغير و انواع آن با در نظر گرفتن لايه های داده ای موجود در VB.NET
متغيرهای ايستا در ASP.NET (۱۳۸۱/۵/۲۲)
توسط: عليرضا پورشاهيد
آشنائی با متغيرهای ايستا در ASP.NET از طريق کاربرد آن در فايل Global.asax.
ساختارهای شرطی در Visual Basic.NET (۱۳۸۰/۸/۳۰)
توسط: مديريت سايت
آشنايی با ساختارهای شرطی در ويژوال بيسيک دات نت
انواع داده ای در Visual Basic.NET (۱۳۸۰/۸/۱۳)
توسط: مديريت سايت
چگونگی تعريف متغير و انواع داده ای در ويژوال بيسيک دات نت

جستجو: بگرد!
جستجوی پيشرفته
نام کاربری |
کلمه عبور |


IranASP.NET - سرويس های XML وب

سرويس های XML وب

شامل مقالاتی جهت آشنائی با XML و سرويس های XML وب. اين سرويس ها نقشی اساسی در توليد برنامه های توزيع يافته در سطح وب دارند.

جستجو با استفاده از وب سرویس گوگل - قسمت دوم (۱۳۸۴/۲/۲۶)
توسط: حامد سعیدی فرد
گوگل به برنامه نویسان یک وب سرویس برای جستجو در دیتابیس خود پیشنهاد می کند. به کمک این وب سرویس شما قادر خواهید بود تا یک وب سایت مشخص یا کل وب را به کمک شاخص های گوگل جستجو کنید و نتایج را به صورت...
جستجو با استفاده از وب سرویس گوگل - قسمت اول (۱۳۸۴/۲/۷)
توسط: حامد سعیدی فرد
گوگل به برنامه نویسان یک وب سرویس برای جستجو در دیتابیس خود پیشنهاد می کند. به کمک این وب سرویس شما قادر خواهید بود تا یک وب سایت مشخص یا کل وب را به کمک شاخص های گوگل جستجو کنید و نتایج را به صورت...
وب سرويس چيست؟ (۱۳۸۱/۴/۱۵)
توسط: حامد بنايی
اين مقاله بخوبی مفهوم وب سرويس را شرح داده و نکات فنی و ملزومات و فوايد آن را به تفصيل برشمرده است.
دات نت و سرويس های وب (۱۳۸۱/۲/۱۶)
توسط: محمد جواد سخائی
بررسی سرويس های وب و روند تكاملی آنها و تاثير دات نت در خصوص آنها بهمراه چالش های سرويس های وب در پروژه دات نت
مقدمه ای بر XML - قسمت ۲ (۱۳۸۰/۱۲/۱۶)
توسط: مسلم ابراهيمی
دنيای XML چگونه است و چگونه بايد شروع كنيم، كاربردهای بيشتر XML
قوانين زبان XML - قسمت ۱ (۱۳۸۰/۱۲/۱۶)
توسط: مسلم ابراهيمی
آشنايی با قوانين زبان و نحوه نگارش سندهای XML
قوانين زبان XML - قسمت ۲ (۱۳۸۰/۱۲/۱۶)
توسط: مسلم ابراهيمی
آشنايی با قوانين زبان و نحوه نگارش سندهای XML
مقدمه ای بر XML (۱۳۸۰/۱۱/۲۷)
توسط: مسلم ابراهيمی
دنيای XML چگونه است و چگونه بايد شروع كنيم، درآينده XML يكی از محورهای دات نت است.

جستجو: بگرد!
جستجوی پيشرفته
نام کاربری |
کلمه عبور |


IranASP.NET - ADO.NET و پايگاه داده

ADO.NET و پايگاه داده

مقالاتی راجع به کلاسهای ADO.NET و دستيابی به بانکهای اطلاعاتی تحت وب.

ايجاد حالت برگشت برای DataReader (۱۳۸۳/۱۰/۱۶)
توسط: لطفعلی خوش نفس
برنامه نويسان پايگاه داده به خوبی با DataReader و قابليتهای بالای آن در كار با بانكهای اطلاعاتی آشنا هستند. کاربرد DataReader برای خواندن سريع تعدادی رکورد از بانک اطلاعاتی و احتمالا نمايش آنها بر...
فرم Login (۱۳۸۲/۹/۳۰)
توسط: مهناز غلامی
تعريف فرمی جهت ورود به صفحات قابل دسترسی (User Authentication)
کار با داده ها با استفاده از DataView (۱۳۸۲/۷/۱۳)
توسط: کيوان نيّری
يکی از اعمال مورد نياز در کار با داده های يک بانک اطلاعاتی جستجو، مرتب سازی و فيلتر کردن داده ها بر حسب نيازمنديهای برنامه کاربردی می باشد.
ذخيره كردن Connection String در فايل Web.Config (۱۳۸۲/۶/۲۹)
توسط: احسان وليزاده
در اين مقاله روش ذخيره كردن Connection String در فايل Web.Config مورد بررسی قرار می‌گيرد.
نمايش اطلاعات در DataGrid (۱۳۸۲/۵/۷)
توسط: مهناز غلامی
نمايش تمام رکوردهای جدول SQL در DataGrid (پر کردن DatasGrid)
برنامه نويسی بهتر با Typed DataSet - قسمت اول (۱۳۸۲/۴/۷)
توسط: مديريت سايت
استفاده از Typed DataSet سبب می شود تا ضمن نوشتن برنامه ای جامع تر و کارآمدتر، قابليت خواندن آن را افزايش داده و نسبت به اجرای آن اطمينان داشته باشيم.
پارامترها در ADO.NET (۱۳۸۱/۹/۲۶)
توسط: مديريت سايت
برای ساخت عبارتهای SQL بهتر است که از پارامترها استفاده کنيد. در اين مقاله با اين پارامترها و نحوه تعريف و بکارگيری آنها آشنا می شويد.
ASP.NET و پايگاه داده - قسمت دوم (۱۳۸۱/۷/۸)
توسط: شاهو طوفانی
اين مقاله به بررسی استفاده از شئ DataSet و بکارگيری شئ DataAdapter در واکشی اطلاعات از يک پايگاه داده می پردازد.
ASP.NET و پايگاه داده – قسمت اول (۱۳۸۱/۵/۲۸)
توسط: شاهو طوفانی
در این مجموعه شما با اصول وروشهای استفاده از پایگاه داده در ASP.NET آشنا می شوید.

جستجو: بگرد!
جستجوی پيشرفته
نام کاربری |
کلمه عبور |


IranASP.NET - گفتگو

گفتگو

گفتگو با متخصصان ASP.NET و IT.

کلاس درس را به خانه ببرید، گفتگو با مهندس مانی قاسم نیا همدانی مبتکر و تهيه کننده «کتاب گويا» (۱۳۸۳/۱۲/۱۳)
توسط: مديريت سايت
مؤسسه انتشارات کتاب های ارغوانی با همکاری شرکت نرم افزاری ساین تک اخیرا فعالیت نوینی را در راستای توسعه و ترویج آموزش الکترونیک آغاز نموده و اولین اثر خود را با عنوان «کتاب گویا» در زمینه Visual C# ...
گفتگو با علی خرد ور متخصص ASP.NET از کانادا (۱۳۸۲/۸/۱۹)
توسط: مديريت سايت
گفتگو با علی خرد ور برنامه نويس ASP.NET از کانادا درباره خودش، NET.، زندگی و کار در کانادا و غيره.
گفتگو با عليرضا مظاهری دارنده مدرک MCAD (۱۳۸۲/۶/۱۰)
توسط: مديريت سايت
راهنمای کاملی در مورد مدرک MCAD و ارتباط آن با ساير مدارک مايکروسافت و چگونگی دريافت آن از زبان دارنده اين مدرک.

جستجو: بگرد!
جستجوی پيشرفته
نام کاربری |
کلمه عبور |


IranASP.NET - مقالات

مقالات

در IranASP.NET مطالب متعددی تحت عنوان مقاله در زمينه ASP.NET موجود است که اين مقالات بصورت موضوعی دسته بندی شده اند. شما با انتخاب موضوع مربوطه، احتمالا می توانيد مقاله مورد نظر خود را بيابيد.
همچنين می توانيد با استفاده از امکان جستجو در مقالات، مقاله مورد نظر را پيدا کنيد.

ADO.NET و پايگاه داده (۹ مقاله)
مقالاتی راجع به کلاسهای ADO.NET و دستيابی به بانکهای اطلاعاتی تحت وب.
ASP کلاسيک (۳۸ مقاله)
ASP مخفف Active Server Pages است که در مقابل ASP.NET که نسل بعدی آن است، اصطلاحا ASP کلاسيک ناميده می شود. ASP روشی کارا و آسان جهت توليد سايتهای پويای وب و برنامه های تحت وب می باشد.
آشنايی با #C (۲ مقاله)
شامل مقالاتی در مورد آموزش و قابليتهای زبان برنامه نويسی #C.
آشنايی با VB.NET (۵ مقاله)
مقالاتی جهت آشنايی و فراگيری زبان ويژوال بيسيک دات نت شامل نحوه تعريف متغير،عملگرها، ساختارهای شرطی، توابع و ساير مواردی که برای يادگيری يک زبان مورد نياز است.
سرويس های XML وب (۸ مقاله)
شامل مقالاتی جهت آشنائی با XML و سرويس های XML وب. اين سرويس ها نقشی اساسی در توليد برنامه های توزيع يافته در سطح وب دارند.
فارسی در وب (۱۲ مقاله)
اين گروه از مقالات به موضوع خط فارسی در وب و سهم ايران يا زبان فارسی در دات نت می پردازد و سعی دارد تا کارهائی که در اين زمينه انجام می شود را حمايت و معرفی نمايد.
فرم های وب (۳۰ مقاله)
فرم های وب يکی از اجزای مهم فناوری ASP.NET است که با استفاده از آنها می توان صفحات پيشرفته وب را به آسانی ايجاد نمود.
گفتگو (۳ مقاله)
گفتگو با متخصصان ASP.NET و IT.
کليات ASP.NET (۶۲ مقاله)
مقالاتی جهت آشنائی با ASP.NET و مجموعه دات نت و شناخت ويژگيها و توانمنديهای آن و ساير موارد مربوطه.

جستجو: بگرد!
جستجوی پيشرفته
نام کاربری |
کلمه عبور |


IranASP.NET - ارسال مقاله

ارسال مقاله

ما شما را دعوت می کنيم تا به جمع نويسندگان IranASP.NET بپيونديد.

اگر مقاله يا نمونه برنامه ای در زمينه ASP.NET داريد که فکر می کنيد برای ديگران مفيد است، IranASP.NET آن را بنام شما در سايت خود منتشر می کند. مطالب خود را به اين آدرس ارسال نمائيد: Site [at] IranASP.net .

رهنمودها و شرايط ارسال مطالب به IranASP.NET :

۱- اگر اولين بار است که برای IranASP.NET مقاله می فرستيد لطفا حتما مشخصات خود شامل:
• نام و نام خانوادگی
• آدرس E-mail
• شرح مختصری در حد يک يا دو خط جهت معرفی سوابق فنی خود
را ارسال نمائيد. در غير اينصورت از درج مطالب ارسالی شما معذوريم.

۲- اطلاعات زير را حتما همراه هر مقاله بفرستيد:
• عنوان مقاله
• خلاصه مقاله در يک چند خط
• کلمات کليدی مقاله (فارسی يا انگليسی) با رعايت فاصله بشکل: کلمه۱ کلمه۲ کلمه۳ ...

۳- مقالات شما اختصاصاً بايد برای سايت IranASP.NET تهيه و ارسال گردد. از پذيرفتن و انتشار مقالاتی که در ديگر سايتها منتشر شده است معذوريم و حق حذف مقالات مذکور در هر زمان برای مدير سايت محفوظ است.

۴- به هيچ عنوان در مقالات خود از تصوير، نمودار، جدول، صفحه آرايی، مدل يا افکت و مانند اينها استفاده نکنيد.

۵- از ارسال مطالب تکراری خودداری نمائيد.

۶- از نمونه برنامه های طولانی استفاده نکنيد.

۷- مقالات ارسالی بايد بصورت فارسی و به شکل HTML يا فايل Word و يا متن تايپ شده درNotepad باشد.

۸- مطالب ارسالی حتی الامکان خلاصه و کوتاه باشد. مطالب بلند را می توانيد در قالب چند مقاله ارائه کنيد.

۹- مطالب دريافتی پس از تائيد توسط مسؤول سايت بنام شما در سايت قرار می گيرد و مسؤول سايت در تائيد، تغيير و يا رد مطالب کاملا آزاد است.

۱۰- با توجه به حجم مقالات دريافتی، انتشار هر مقاله ممکن است تا يکماه زمان ببرد.

۱۱- هيچ مطلبی به نويسنده عودت داده نخواهد شد.

۱۲- مطالب خود را تنها از طريق E-mail و بصورت يک فايل الصاقی (Attachment) و حتی الامکان بصورت zip شده به آدرس Site [at] IranASP.net ارسال نمائيد.

منتظر دريافت مطالب شما هستيم.
جستجو: بگرد!
جستجوی پيشرفته
نام کاربری |
کلمه عبور |


IranASP.NET - ساختارهای شرطی در Visual Basic.NET

ساختارهای شرطی در Visual Basic.NET

مديريت سايت | اين مقاله ۶۲۸۹ بار تاکنون ديده شده است.
۱۳۸۰/۸/۳۰ | برای وبلاگ برای وبلاگ دريافت کد
آشنايی با ساختارهای شرطی در ويژوال بيسيک دات نت

در اين گفتار برآنيم تا ساختارهای شرطی در ويژوال بيسيک دات نت را بررسی کنيم. اين ساختارها If..Then و Select..Case می باشند.

ساختار If..Then
ابتدائی ترين ساختار شرطی در ويژوال بيسيک دات نت ساختار If..Then می باشد. با استفاده از اين ساختار هنگامی که شرط مورد نظر برقرار باشد، می توان دستور يا دستورات متعددی را اجرا نمود.

بعنوان مثال در برنامه زير اگر زمان سيستم بعد از ظهر را نشان دهد، جمله "Good Evening IranASP.NET" بر روی صفحه نمايش داده می شود.

<%
Dim myTime As DateTime
myTime = Now

if Hour(myTime) >= 12 then
Response.write ("Good Evening IranASP.NET !")
end if
%>

همچنين ساختار If..Then عبارت Else را هم پشتيبانی می کند. اگر شرط مربوط به If برقرار نباشد، دستورات موجود در قسمت Else اجرا می شوند. به مثال زير توجه فرمائيد.

<%
Dim myTime As DateTime
myTime = Now

if Hour(myTime) >= 12 then
Response.write ("Good Evening IranASP.NET !")
else
Response.write ("Good Morning IranASP.NET !")
end if

%>

ساختار Select..Case
در ساختار Select..Case می توان مقداری را با مقادير مختلفی مقايسه کرده و دستورات مربوط به مقدار يافت شده را اجرا نمود. بعنوان مثال قطعه برنامه زير پيامهای مختلفی را برحسب نوع مرورگر نمايش می دهد.

<%
Dim strBrowser As String

strBrowser = Request.Browser.Browser
Select Case strBrowser
Case "IE"
Response.Write( "You are using Internet Explorer!" )
Case "Netscape"
Response.WRite( "You are using Netscape!" )
Case Else
Response.Write( "What browser are you using?" )
End Select
%>

دقت داشته باشيد که ساختار Select..Case در برنامه فوق دارای يک قسمت Case Else می باشد. هرگاه هيچ يک از حالات مقايسه ای برقرار نبود، دستورات موجود در قسمت Case Else اجرا می گردند. استفاده از Case Else اختياری است.

همه مقالات آشنايی با VB.NET را ببينيد.
جستجو: بگرد!
جستجوی پيشرفته
نام کاربری |
کلمه عبور |


IranASP.NET - درس چهارم: روال ها و توابع در ASP

درس چهارم: روال ها و توابع در ASP

محمد جواد سخائی | اين مقاله ۵۹۶۰ بار تاکنون ديده شده است.
۱۳۸۰/۹/۳ | برای وبلاگ برای وبلاگ دريافت کد
بررسی روال ها و زيربرنامه ها در ASP کلاسيک

يک روال يا تابع مجموعه ای از يک يا چند دستور است که بصورت گروهی اجرا می شوند. يک تابع مانند يک روال است با اين تفاوت که مقداری را برمی گرداند.

در VBScript برای تعريف يک روال از عبارت Sub و برای تعريف يک تابع از Function استفاده می کنيم. در VBScript جهت برگرداندن يک مقدار از تابع، بايد مقدار مورد نظر را مانند زير به نام تابع نسبت دهيم.

myFunction = myValue

در جاواسکريپت برای نوشتن يک روال يا تابع تنها از عبارت function استفاده می کنيم. بعبارت ديگر يک روال تابعی است که مقداری را برنمی گرداند. جهت برگرداندن يک مقدار در توابع جاوااسکريپت از دستور return استفاده می کنيم.

return myValue;

در برنامه های ASP ، می توان يك روال را از طريق VBScript و يا بالعكس صدا زد . برای صدا زدن يك روال از طريق يك برنامه ASP كه با زبان VBScript نوشته شده است ، از دستور Call كه بدنبال آن نام روال می آيد، استفاده می گردد. در صورتيكه يك روال نيازمند پارامتر باشد ، می بايست پارامترهای مربوطه را بين پرانتز قرار داده و آنها را در اختيار روال قرار داد . در صورتيكه از فرمان call برای صدا زدن يك روال استفاده نگردد ، پارامترهای مربوطه را نبايد بين پرانتز قرار داد. قرار دادن پرانتز در صورتيكه يك روال دارای پارامتر نباشد ، اختياری است.

در زمانيكه اسكريپت های موجود در يك برنامه ASP به زبان جاوااسكريپت نوشته شده باشند و قصد صدا زدن يك روال را داشته باشيم كه با زبان VBScript و يا جاوااسكريپت نوشته شده باشد ، قرار دادن پرانتز بعد از نام روال ضروری است.

در مثال زير با نحوه صدا زدن يك روال (تابع Zarb نوشته شده با VBScript ) توسط يك برنامه ASP آشنا خواهيم شد.

<html>
<head>
<%
Sub Zarb(num1,num2)
response.write(num1*num2)
End Sub
%>
</head>
<body>
<p>Calling a Subroutine with Call statement: <%call Zarb(7,6)%>
<p>Calling a Subroutine without Call statement: <%Zarb 6,7%>
</body>
</html>

در مثال زير با نحوه صدازدن دو روال ( يكی با جاوااسكريپت و ديگری با VBScript نوشته شده است) در يك برنامه ASP آشنا می شويم.

<html>
<head>
<%
Sub ZarbVBScript(num1,num2)
Response.Write(num1*num2)
End Sub
%>

<script language="javascript" runat="server">
function ZarbJavascript(num1,num2)
{
Response.Write(num1*num2)
}
</script>
</head>
<body>
<p>The Result of the VBScript Subroutine: <%call ZarbVBScript(6,7)%>
<p>The Result of the JavaScript Subroutine: <%call ZarbJavascript(6,7)%>
</body>
</html>

همه مقالات ASP کلاسيک را ببينيد.
جستجو: بگرد!
جستجوی پيشرفته
نام کاربری |
کلمه عبور |


IranASP.NET - درس پنجم: فرم ها در ASP - قسمت اول

درس پنجم: فرم ها در ASP - قسمت اول

محمد جواد سخائی | اين مقاله ۵۴۱۸ بار تاکنون ديده شده است.
۱۳۸۰/۹/۵ | برای وبلاگ برای وبلاگ
دريافت اطلاعات از ورودی بوسيله فرم ها

يكی از مزايای برنامه های ASP قابليت ايجاد ارتباط متقابل با كاربران است. همانطور كه می دانيد يكی از بخش های مهم هر نرم افزار بخش رابط كاربر است كه كاربران را قادر می سازد بسرعت و بسادگی با نرم افزار مربوطه ارتباط برقرار كرده و از پتانسيل های موجود در يك نرم افزار استفاده نمايند.

بخش رابط كاربر در اغلب نرم افزارهای وب به عهده مرورگرها گذاشته شده است. اين نرم افزارها دارای امكانات لازم جهت ايجاد يك محيط رابط كاربر مناسب می باشند. يكی از مسائل مهم در هر نرم افزار نحوه اخذ اطلاعات از كاربران و در نهايت پردازش و ارائه خروجی های لازم است. بدون شك پتانسيل اخذ اطلاعات از استفاده كننده يك نرم افزار را می توان نقطه آغازين هر نوع برنامه كامپيوتری دانست.

در برنامه های ASP ، با استفاده از فرم ها می توان اقدام به اخذ اطلاعات از كاربران نمود. پس از ارسال اطلاعات در قالب فرم ها زمينه پردازش آنها بر روی سرويس دهنده فراهم می گردد. نكته مهم در اين زمينه اين است كه محل اخذ اطلاعات و محل پردازش اطلاعات دو محل كاملا متمايز از هم بوده و ايده پردازش سيستمهای سرويس گيرنده / سرويس دهنده در اين مدل معنای خاص خود را پيدا می كند.

در برنامه های ASP با استفاده از دستورات Request.QueryString و Request.Form امكان اخذ اطلاعات فراهم می گردد.

Request.QueryString
با استفاده از دستور فوق می توان اقدام به جمع آوری اطلاعات يك فرم بصورت متن نمود. اطلاعات جمع آوری شده توسط متد GET ارسال خواهند شد. استفاده از متد فوق جهت ارسال اطلاعات يك فرم دارای محدوديت حجم اطلاعات ارسالی است.

مثال زير يك فرم ساده را كه دارای دوفيلد متن معمولی با نام FirstName و LastName است ، ايجاد و پس از تكميل فرم توسط كاربر و همزمان با فشردن دكمه Send آنها را برای برنامه GetName.asp بر روی سرويس دهنده ارسال ميدارد.

<form method="GET" action="../GetName.asp">
First Name: <input type="text" name="FirstName"><br>
Last Name : <input type="text" name="LastName"><br>
<input type="submit" value="Send">
</form>

در صورتيكه فرم فوق پس از تكميل توسط متد GET ( همانطور كه در تعريف فرم نيز آورده شده است ) ارسال گردد و كاربر در قسمت نام کلمه Javad ودر قسمت نام خانوادگی کلمه Sakhaee را تايپ كرده باشد ، آدرس زير پس از فشردن دكمه Send برای سرويس دهنده ارسال می گردد.

http://www.Mycompany.com/GetName.asp?FirsName=Javad&LastName=Sakhaee

آدرس فوق در بردارنده چندين نكته مهم است : اولا نام فايل (برنامه ای) كه می بايست بر روی سرويس دهنده فعال گردد را مشخص ميسازد ( GetName.asp ) و ثانيا داده های اخذ شده و ذخيره شده در دو متغير با نام FirstName و LastName را در اختيار برنامه فوق قرار خواهد داد. هر يك از پارامترهای تايپ شده توسط علامت & از ديگری جدا شده است. تا اينجای قضيه، فرم توسط كاربر تكميل و ارسال شده است در ادامه می بايست با ماهيت برنامه GetName.asp كه بر روی سرويس دهنده قرار دارد و می بايست بر روی داده های ارسالی عمليات مورد نظر را انجام دهد ، آشنا شويم. اين برنامه می تواند دارای اسكريپت هائی مطابق زير باشد :

Welcome to IranASP.NET site
<%
response.write(request.querystring("FirstName"))
response.write("&nbsp;")
response.write(request.querystring("LastName"))
%>

برنامه فوق پس از اجرا ، خروجی زير را بر روی مرورگر كاربر به نمايش در می آورد.

Welcome to IranASP.NET site Javad Sakhaee

Request.Form
در صورتيكه اطلاعات موجود در يك فرم را از طريق متد POST اخذ كرده باشيم ، از دستور فوق استفاده می شود. برخلاف متد GET اين متد ( POST ) دارای محدوديت از بعد حجم اطلاعات ارسالی نبوده و امنيت ارسال اطلاعات نيز دارای مقبوليت بيشتری است.

در صورتيكه فرم فوق پس از تكميل توسط متد POST ( در تعريف فرم می بايست مشخص گردد ) ارسال گردد و كاربر در بخش نام Javad ودر بخش نام خانوادگی Sakhaee را تايپ كرده باشد ، آدرس زير پس از فشردن دكمه Send برای سرويس دهنده ارسال می گردد.

http://www.Mycompany.com/GetName.asp

برنامه GetName.asp كه بر روی سرويس دهنده قرار دارد و می بايست بر روی داده های ارسالی عمليات مورد نظر را انجام دهد ، دارای اسكريپت هائی مطابق زير است:

Welcome to IranASP.NET site
<%
response.write(request.form("FirstName"))
response.write("&nbsp;")
response.write(request.form("LastName"))
%>

همه مقالات ASP کلاسيک را ببينيد.
جستجو: بگرد!
جستجوی پيشرفته
نام کاربری |
کلمه عبور |


IranASP.NET - درس پنجم: فرم ها در ASP - قسمت دوم

درس پنجم: فرم ها در ASP - قسمت دوم

محمد جواد سخائی | اين مقاله ۶۸۵۱ بار تاکنون ديده شده است.
۱۳۸۰/۹/۸ | برای وبلاگ برای وبلاگ دريافت کد
دريافت اطلاعات از ورودی بوسيله فرم ها

در اين گفتار بمنظور آشنائی بيشتر با نحوه عملكرد فرم ها و پردازش آنها به بررسی چند مثال خواهيم پرداخت.

استفاده از متد GET جهت اخذ و ارسال اطلاعات
در اين مثال با نحوه ايجاد يك ارتباط متقابل با كاربر از طريق تكميل يك فرم توسط كاربر، ارسال آن توسط متد GET ، پردازش فرم و ارائه پاسخ های لازم از طرف سرويس دهنده با استفاده از دستور Request.QueryString آشنا خواهيم شد.

<form action="Les5p2sam1.asp" method="GET">
Please type your first name:<input type="text" name="FirstName"><br>
<input type="submit" value="Submit">
</form>
<%
If Request.QueryString("FirstName") <> "" Then
Response.Write ("Hello " & Request.QueryString("FirstName") & "!<br>")
Response.Write ("Did you visit <a href=""http:/www.iranasp.net"">IranASP.NET</a> yet?")
End If
%>

استفاده از متد POST جهت اخذ و ارسال اطلاعات
در اين مثال نحوه ايجاد يك ارتباط متقابل با كاربر را از طريق تكميل يك فرم توسط كاربر، ارسال آن توسط متد POST ، پردازش فرم و ارائه پاسخ های لازم از طرف سرويس دهنده با استفاده از دستور Request.Form را آشنا خواهيم شد.

<form action="Les5p2sam2.asp" method="POST">
Please type your first name:<input type="text" name="FirstName"><br>
<input type="submit" value="Submit">
</form>
<%
If Request.Form("FirstName")<>"" Then
Response.Write ("Hello " & Request.Form("FirstName") & "!")
Response.Write ("Did you visit <a href=""http:/www.iranasp.net"">IranASP.NET</a> yet?")
End If
%>

در اين مثال با نحوه ايجاد ارتباط متقابل با كاربر از طريق استفاده از دكمه های راديوئی ( Radio Buttom ) و بكمك دستور Request.Form آشنا خواهيم شد.

<%
Dim site
site=Request.Form("site")
%>
<form action="Les5p2sam3.asp" method="POST">
<p>Please select your favorite Site:</p>
<input type="radio" name="site"
<%
if site = "IranASP.NET" then
Response.Write(" checked")
end if
%>
value="IranASP.NET">IranASP.NET<br>
<input type="radio" name="site"
<%
if site = "Other websites!!" then
Response.Write(" checked")
end if
%>
value="Other websites!!">Other websites!!<br>
<input type="submit" value="Submit">
</form>
<%
if site<>"" then
Response.Write("<p>Your favorite site is: " & site & "</p>")
end if
%>

همه مقالات ASP کلاسيک را ببينيد.
جستجو: بگرد!
جستجوی پيشرفته
نام کاربری |
کلمه عبور |


IranASP.NET - توضيح در برنامه

توضيح در برنامه

مديريت سايت | اين مقاله ۴۱۰۹ بار تاکنون ديده شده است.
۱۳۸۰/۹/۱۱ | برای وبلاگ برای وبلاگ
استفاده از توضيحات در برنامه

اغلب برنامه نويسان هنگامی که می خواهند برنامه چند ماه پيش خود را مرور کنند با مشکل مواجه شده و ممکن است دقيقا برنامه خود را متوجه نشوند. اين مشکل از آنجا ناشی می شود که احتمالا آن برنامه قديمی خوب توضيح داده نشده يا بعبارت ديگر Comment نشده است.

در ASP اگر از VBScript استفاده می کنيد براحتی می توانيد با استفاده از علامت " ' " در متن برنامه خود توضيحات لازم را قرار دهيد. به مثال زير توجه کنيد:

<%
' Create a variable to hold the user's name
Dim strName
...
%>

اگر از JScript استفاده می کنيد بايد از علامت " // " استفاده کنيد. به مثال زير توجه کنيد:

<%
// Create a variable to hold the user's name
var strName;
...
%>

دقت داشته باشيد که هر جا از علامت های فوق استفاده کنيد همه محتويات خط از همان نقطه تا آخر خط بعنوان توضيح تلقی شده و اجرا نمی شود.

اغلب اين سوال پيش می آيد که "چه موقع بايد از توضيح استفاده کرد؟" شايد قاعده مشخصی در اين باره وجود نداشته باشد اما همواره در هر نقطه ای از برنامه اگر فکر می کنيد به توضيح نياز دارد، در مورد آن خست به خرج نداده و حتما آن را توضيح دهيد.

شايد بتوان يک قاعده کلی در نظر گرفت مبنی بر اينکه همواره هنگام تعريف متغيرهای جديد، هنگام تعريف روال ها و توابع، هنگام دسته بندی دستورات مرتبط با هم در يک بلوک از برنامه (جهت بيان عملی که در بلوک انجام می شود) يا نوشتن دستورات پيجيده و مشکل از توضيحات استفاده کنيم.

با استفاده از توضيحات در برنامه، نگهداری برنامه های ASP خود را به طور چشمگيری آسان می کنيم و برنامه های ما برای ديگران قابل خواندن است. اگر همواره در حين برنامه نويسی بصورت کم کم توضيحات را اضافه کنيم، در طول زمان مشاهده می کنيم که همه برنامه يا برنامه های ما دارای توضيحات کافی هستند و مجبور نيستيم که برای انبوهی از برنامه ها به يکباره مقدار زيادی توضيح اضافه کنيم.

يک روش خوب برای اين منظور اين است که ابتدا توضيح مورد نظر را برای هر قطعه از برنامه قبل از نوشتن آن قطعه بنويسيم.

همه مقالات ASP کلاسيک را ببينيد.
جستجو: بگرد!
جستجوی پيشرفته
نام کاربری |
کلمه عبور |


IranASP.NET - درس ششم: کوکی ها در ASP

درس ششم: کوکی ها در ASP

محمد جواد سخائی | اين مقاله ۵۲۶۳ بار تاکنون ديده شده است.
۱۳۸۰/۹/۱۱ | برای وبلاگ برای وبلاگ دريافت کد
آشنايی با کوکی ها و نحوه بکارگيری آنها

Cookie يا کوکی همانند برچسبی است كه در زمان مسافرت با هواپيما بر روی بار مسافر قرار می گيرد. اين برچسب يك شماره سريال بوده كه يك نسخه از آن نيز در اختيار مسافر قرار گرفته تا پس از رسيدن به مقصد با اتكاء به آن امكان برداشتن بار خود را داشته باشد. در حقيقت برچسب فوق مولفه ای است كه بصورت منحصر بفرد بار يك مسافر را مشخص می كند.

هنگاميكه به يك وب سايت مراجعه می کنيم، ممکن است که يك برچسب خاص در يك آدرس معين و مشخص بر روی هارد ديسک كامپيوتر كاربر قرار گيرد. در مراحل و زمانهای بعدی كه مجددا به سايت مورد نظر مراجعه می کنيم، سرويس دهنده وب سايت مزبور از اطلاعات ذخيره شده با اين برچسب استفاده و متناسب با مقادير ذخيره شده در آن از خود واكنش نشان می دهد. هر وب سايت دارای يك برچسب اختصاصی مربوط به خود بوده كه امكان استفاده از مقادير مندرج در آن و حتی بهنگام سازی توسط سرويس دهنده وب را ميسر خواهد کرد. مثلا می توان بر روی برچسب فوق رنگ مورد علاقه كاربر اينترنت در رابطه با يك سايت را ثبت نمود. بدين ترتيب در صورتيكه كاربر فوق مجددا به سايت مورد نظر مراجعه کند، ( برچسب مربوط به آن در مراحل قبل ايجاد و بر روی كامپيوتر سرويس گيرنده قرار گرفته است ) تمامی صفحاتی كه برای وی به نمايش درخواهد آمد با استناد به رنگ مورد نظر كاربر می باشد.

اطلاعات ذخيره شده در کوکی می تواند شامل مجموعه ای از اطلاعات خاص در رابطه با پارامترهای مربوط به نحوه نمايش صفحه وب نظير رنگ، رويه زمينه و فونت های استفاده شده و يا اطلاعاتی در رابطه با تشريح عملياتی باشد كه ملاقات كننده سايت در جلسه قبل انجام داده است. يكی از كاربردهای مهم کوکی امكان تبادل اطلاعات بين صفحات وب است. در چنين حالتی می توان آنها را بعنوان مجموعه ای از متغيرهای سراسری فرض كرد كه دامنه اعتبار آنها در تمام وب سايت است.

از يك کوکی برای مشخص نمودن يك كاربر نيز استفاده می شود. يك کوکی در اصل يك فايل كوچك بوده كه سرويس دهنده آن را با مرورگر يك كاربر تلفيق می نمايد. هر زمان كه مرورگر درخواست يك صفحه را داشته باشد کوکی مربوطه نيز ارسال خواهد شد. با استفاده از اسكريپت های ASP می توان هم به مقادير ذخيره شده در يك کوکی دستيابی داشت و هم مقادير آن را تغيير داد.

تنظيم کوکی
برای مقدار دهی مورد نظر يك کوکی می توان از دستور Response.Cookies استفاده كرد. در صورتيكه کوکی وجود نداشته باشد، آن را ايجاد و مقدار مورد نظر را به آن نسبت خواهد داد. در مثال زير يك کوکی بنام userid و مقدار 100618 برای مرورگر ارسال می گردد. اين کوکی تا زمانيكه كاربر به سايت مورد نظر وصل است وجود خواهد داشت. اين دستور می بايست قبل از تگ <html> قرار گيرد.

<%Response.Cookies("userid")=100618%>

در صورتيكه بخواهيم كاربری را كه مرورگر خود را متوقف كرده و مجددا آن را اجرا نموده باز هم شناسائی نمائيم، می بايست از صفت Expires بهمراه دستور Response.Cookies استفاده نموده و تاريخ اعتبار آن را مشخص سازيم.

<%
Response.Cookies("userid")=100618
Response.Cookies("userid").Expires="May 15, 2005"
%>

دستيابی به مقادير کوکی
برای دستيابی به مقدار يك کوکی می بايست از دستور Request.Cookies استفاده نمائيم. در مثال زير می خواهيم مقدار ذخيره شده در userid را بخوانيم ( بازيابی 100618 )

<%Response.Write(Request.Cookies("userid"))%>

تنظيم مسيرهای کوکی
هر کوکی كه در مرورگر ذخيره می گردد دارای اطلاعاتی در رابطه با مسير است. زمانيكه مرورگر درخواست فايلی را داشته باشد كه مسير آن دقيقا در کوکی مشخص شده باشد مرورگر کوکی را برای سرويس دهنده ارسال خواهد كرد.

برای مشخص نمودن يك مسير برای يك کوکی می توان با استفاده از صفت Path در كنار دستور Response.Cookies به اين هدف نائل شد. در مثال زير مسير Sales\Customer\Profiles به يك کوکی با نام Zip نسبت داده می شود.

<%
Response.Cookies("Zip")="12"
Response.Cookies("Zip").Expires="January 21, 2004"
Response.Cookies("Zip").Path="/Sales/Customer/Profiles/"
%>

تمامی مرورگرها امكان استفاده از کوکی را ندارند. در چنين حالتی و در صورتيكه يك برنامه نيازمند ارتباط با مرورگر باشد می توان اژ روش های ديگری جهت ارسال اطلاعات از يك صفحه به صفحه ديگر در يك برنامه استفاده نمود.

در اين مثال با نحوه ايجاد يك کوکی welcome آشنا می شويد.

<%
response.cookies("NumVisits").Expires = date + 365
num=request.cookies("NumVisits")
If num = "" Then
response.cookies("NumVisits") = 1
Else
response.cookies("NumVisits") = num + 1
End If
%>
<html>
<body>
<%if num="" then%>
Welcome! This is the first time you are visiting this Web page.
<%else%>
You have visited this Web page <%response.write(num)%> times before
<%end if%>
</body>
</html>

همه مقالات ASP کلاسيک را ببينيد.
جستجو: بگرد!
جستجوی پيشرفته
نام کاربری |
کلمه عبور |


IranASP.NET - راهكارهائی برای بهبود طراحی صفحات ASP – بخش دوم

راهكارهائی برای بهبود طراحی صفحات ASP – بخش دوم

محمد جواد سخائی | اين مقاله ۴۶۸۱ بار تاکنون ديده شده است.
۱۳۸۰/۱۲/۱۴ | برای وبلاگ برای وبلاگ
در اين مقاله سعی می شود كه با ارائه يك ديدگاه مهندسی نرم افزار و با استفاده از دستورات Server.Execute و Server.Transfer اقدام به طراحی صفحات ASP نمود.

در بخش اول اين مقاله نحوه استفاده از فايل های ضميمه بعنوان اولين رويكرد جهت طراحی صفحات ASP ماژولار، تشريح گرديد. در اين مقاله به بررسی امكانات Server.Execute و Server.Transfer بعنوان دومين رويكرد جهت طراحی صفحات ماژولار خواهيم پرداخت.

Server.Execute
از امكان فوق جهت طراحی صفحات ماژولار ASP می توان استفاده كرد. در صورت استفاده از امكان فوق در يك صفحه، كنترل به صفحه ديگر منتقلشده و پس از اجرای مجموعه دستورات و امكانات موجود در صفحه صدازده شده، كنترل مجددا به صفحه اوليه برگردانده می شود. بنابراين می توان برخی از صفحات را بصورت عمومی طراحی ( كيت های نرم افزاری ) و در ادامه از طريق صفحات ديگر آنها را فعال و زمينه استفاده از خدمات دهی آنها به صفحات صدازننده را فراهم نمود. هر كيت نرم افزاری پس از ارائه خدمات مربوطه خود، كنترل را برای ادامه سرويس دهی در اختيار صفحه صدا زننده خود برمی گرداند.

مثال ۱: در مثال زير صفحه شماره يك ( Page1 ) با استفاده از Server.Execute صفحه دوم (Page2) را فعال و صفحه دوم پس از اجرا و اتمام وظايف محوله، مجددا كنترل را به صفحه اول برمی گرداند.

/Myscripts/Page2.asp"
Server.Execute(JumpPage)
...
%>

Page2.asp
<%
...
%>

نكته بسيار مهم در اين فراخوانی امكان استفاده از اشياء از قبل ساخته شده (Built-in) و استفاده شده در صفحه اوليه، توسط صفحه صدا زده شده است. به عبارت ديگر تمامی نمونه اشياء استفاده شده در صفحه اوليه با صفحه صدازده شده به اشتراك گذاشته خواهند شد. مثلا در صورتيكه در صفحه اوليه از شئ Request استفاده شده و به كمك مجموعه های Form و يا QueryString اقدام به خواندن اطلاعاتی از طريق يك فرم شده است، اين مقادير نيز توسط صفحه صدا زده شده قابل استفاده خواهند بود.

بهترين جايگاه استفاده از Server.Execute زمانی است كه قصد استفاده پويا از فايل های ديگری را داشته باشيم ( Dynamic Include ) در صورتيكه چنين هدفی را دنبال نمی كنيم، استفاده از SSI توصيه می گردد.

Server.Transfer
از امكان فوق می توان در جهت بهبود طراحی صفحات ASP استفاده كرد. ويژگی فوق را نمی توان بعنوان گزينه ای برای طراحی صفحات ماژولار نظير SSI و يا Server.Execute در نظر گرفت. عملكرد امكان فوق در اكثر موارد مشابه Server.Execute است با اين تفاوت مهم كه پس از انتقال به صفحه دوم، كنترل مجددا به صفحه اول ( صدازننده) برگردانده نخواهد شد.

مثال ۲: در مثال زير صفحه شماره يك ( Page1 ) با استفاده از Server.Transfer صفحه دوم (Page2) را فعال و صفحه دوم پس از اجرا و اتمام وظايف محوله، كنترل را به صفحه اول برنمی گرداند.

/Myscripts/Page2.asp"
Server.Transfer(JumpPage)
...
%>

Page2.asp
<%
...
%>

تمامی اشياء Built-in در صفحه اول در اختيار صفحه دوم نيز قرار گرفته و زمينه استفاده از مجموعه های مرتبط با هر يك از اشياء در اين صفحه نيز فراهم خواهد شد.

جايگاه استفاده از Server.Transfer در مواردی است كه بخواهيم پس از انجام عمليات خاصی، نقطه خروج آنها را به يك صفحه خاص هدايت نمائيم. مثلا فرض كنيم كه دارای سايتی هستيم كه از طريق صفحات متفاوت، اطلاعاتی توسط كاربران ارسال و در نهايت در بانك های اطلاعاتی از قبل طراحی شده قرار می گيرند. در چنين حالتی می توان پس از اطمينان از صحت اطلاعات و ذخيره آنان در بانك های اطلاعاتی مرتبط، صفحه ای با نام SaveOk.asp داشته باشيم كه در اين صفحه به كاربر اعلام می نمائيم، اطلاعات شما دريافت و در بانك اطلاعاتی سيستم ذخيره گرديد. صفحه فوق را می توان از طريق صفحات متفاوت ديگر بكمك Server.Transfer فعال نمود. با اين كار مسئوليت ارائه پيامهای دريافت اطلاعات بهمراه پارامترهای مربوطه متمركز شده و از نوشتن كدهای تكراری در اين خصوص جلوگيری بعمل می آيد. وضعيت فوق را می توان در موارد بسياری نظير: متمركز نمودن پيامهای خطا، متمركز نمودن كنترل های لازم بر روی فيلدهای موجود بر روی يك فرم، متمركز نمودن اطلاعات كمكی (Help ) به كاربران سايت و استفاده نمود.

همه مقالات ASP کلاسيک را ببينيد.
جستجو: بگرد!
جستجوی پيشرفته
نام کاربری |
کلمه عبور |


IranASP.NET - مقدمه ای بر XML - قسمت ۲

مقدمه ای بر XML - قسمت ۲

مسلم ابراهيمی | اين مقاله ۵۹۸۷ بار تاکنون ديده شده است.
۱۳۸۰/۱۲/۱۶ | برای وبلاگ برای وبلاگ
دنيای XML چگونه است و چگونه بايد شروع كنيم، كاربردهای بيشتر XML

برای داد و ستد اطلاعات
با XML اطلاعات ميتواند بين سيستم های ناسازگار داد و ستد شود.
در دنيای واقعی، سيستم های كامپيوتری و بانك های اطلاعاتی شامل اطلاعات در فرمت های ناسازگار هستند. يكی از وقت گيرترين چالش ها برای گسترش دهندگان، انتقال اطلاعات بين چنين سيستمهايی شده است.

XML و B2B
با استفاده از XML اطلاعات تجاری می تواند روی اينترنت داد و ستد شود. در آينده ای نزديك بايد منتظر شندن خبرهای بيشتری از XML و B2B(Business to Business) باشيم.
XML می رود تا زبان اصلی برای داد و ستد اطلاعات اقتصادی بين تجارت ها، روی اينترنت بشود. امروزه تعداد زيادی از برنامه های B2B در حال گسترش است.

XML برای توزيع اطلاعات
با XML ، فايل های متنی می توانند برای توزيع اطلاعات استفاده گردند (در اينجا منظور از توزيع، انتقال و پخش اطلاعات از يك نوع سيستم به سيستمهای نوع ديگر است).
زمانی كه اطلاعات در فايل های متنی ذخيره شود، XML يك روش مستقل از سخت افزار و نرم افزار برای انتقال و توزيع اطلاعات فراهم می كند.
اين روش باعث ميشود كه ايحاد و ساخت اطلاعاتی كه برنامه های كاربردی مختلف بتوانند با آن كار كنند بسيار آسان بشود. همچنين توسعه و ارتقاء يك سيستم به سيستم عامل، سرور، برنامه كاربردی و جستجوگرهای جديد را نيز آسانتر مينمايد.

XML برای ذخيره اطلاعات
با XML فايل های متنی ميتوانند برای ذخيره اطلاعات استفاده بشوند.
XML همچنين ميتواند برای ذخيره اطلاعات در فايلها و بانك های اطلاعاتی مورد استفاده قرارگيرد. برنامه هايی ميتواند نوشته شوند كه اطلاعات را در منابع ذخيره و فراخوانی كنند و برنامه های اصلی ميتوانند برای نمايش اطلاعات استفاده شود.

XML ميتواند اطلاعات شما را مفيدتر كند
XML اطلاعات شما را برای كاربرهای بيشتری قابل دسترس ميكند.
به دليل مستقل بودن XML از سخت افزار و نرم افزار و برنامه، شما ميتوانيد اطلاعات خود را برای برنامه هايی غير از جستجوگرهای HTML هم قابل دسترس نماييد.
به اين ترتيب اطلاعات شما در همه انواع برنامه های كاربردی ديگر قابل استفاده است، برای مثال يك برنامه كاربردی ميتواند اطلاعات شما را كه در يك بانك اطلاعاتی ذخيره شده است برای نابينايان به خروجی مخصوص خود انتقال دهد.

XML و زبان های جديد
XML مادر WAP و WML است. WML كه برای دستگاه های دستی مانند موبايل ها به منظور ارتباط با اينترنت مورد استفاده قرار ميگيرد، در XML نوشه شده است.

همه مقالات سرويس های XML وب را ببينيد.
جستجو: بگرد!
جستجوی پيشرفته
نام کاربری |
کلمه عبور |


IranASP.NET - قوانين زبان XML - قسمت ۱

قوانين زبان XML - قسمت ۱

مسلم ابراهيمی | اين مقاله ۵۹۶۴ بار تاکنون ديده شده است.
۱۳۸۰/۱۲/۱۶ | برای وبلاگ برای وبلاگ
آشنايی با قوانين زبان و نحوه نگارش سندهای XML

قوانين زبان XML بسيار ساده و واضح است و برای استفاده و يادگيری ساده است، به همين دليل ساخت نرم افزارهايی كه با XML كار كنند بسيار ساده شده است.

مثالی از يك سند XML
سندهای XML خود-شرح (self-describing) هستند و قوانين ساده ای دارند.

<?xml version="1.0" encoding="ISO-8859-1"?>
<note>
<to>Tove</to>
<from>Jani</from>
<heading>Reminder</heading>
<body>Dont forget me this weekend!</body>
</note>

خط اول در سند - اعلان XML - نسخه و encoding آن را تعريف می كند.در اين مورد نگارش 1 از XML و مجموعه نويسه ISO-8859-1 (كه مربوط به اروپای غربی است) استفاده شده است.

خط بعد عنصر اصلی سند را تعريف می كند (مثل اين است كه می گويد: اين سند يك يادداشت است).

<note>

چهار خط بعدی، چهار زير-عنصر از عنصر اصلی تعريف می كند (body, heading, form, to ):

<to>Tove</to>
<from>Jani</from>
<heading>Reminder</heading>
<body>Dont forget me this weekend!</body>

و سر انجام خط آخر ، پايان عنصر اصلی را تعريف می كند.

</note>

تمام عناصر XML بايد برچسب بستن را داشته باشند.
در XML، حذف برچسب های بستن مجاز نيست.
در HTML بعضی از عناصر نياز به برچسب بستن ندارد، كد زير در HTML مجاز نيست:

<p>This is a paragraph
<p>This is another paragraph

در XML همه عناصر بايد برچسب بستن را داشته باشند:

<p>This is a paragraph</p>
<p>This is another paragraph</p>

نكته: ممكن است شما از مثال قبل متوجه شده باشيد كه خط اعلان XML (خط اول) دارای برچسب بستن نيست، اين خطا نيست. خط اعلان XML قسمتی از خود سند XML نيست و يك عنصر از XML نيست و نبايد برچسب بستن داشته باشد.

برچسب های XML نسبت به حروف كوچك و بزرگ حساس هستند (case sensitive).
XML در اين مورد برعكس HTML است.
در XML برچسب <Letter> با برچسب <letter> فرق می كند.
بنابراين برچسب های بازكردن و بستن بايد در يك حالت از نظر حروف كوچك و بزرگ باشند:

<Message>This is incorrect</Message>
<message>This is correct</message>

همه مقالات سرويس های XML وب را ببينيد.
جستجو: بگرد!
جستجوی پيشرفته
نام کاربری |
کلمه عبور |


IranASP.NET - قوانين زبان XML - قسمت ۲

قوانين زبان XML - قسمت ۲

مسلم ابراهيمی | اين مقاله ۵۲۶۰ بار تاکنون ديده شده است.
۱۳۸۰/۱۲/۱۶ | برای وبلاگ برای وبلاگ
آشنايی با قوانين زبان و نحوه نگارش سندهای XML

همه عناصر XML بايد به طور صحيحی در يكديگر قرار گرفته باشند.
نادرست قرار گرفتن برچسب ها برای XML معنی دار نيست.
در HTML بعضی از عناصر ميتوانند به صورت نادرست در يكديگر قرار بگيرند، شبيه اين:

<b><i>This text is bold and italic</b></i>

در صورتی كه در XML اين روش نادرست است و عناصر بايد درست در يكديگر قرار بگيرند، شبيه اين:

<b><i>This text is bold and italic</i></b>

همه سندهای XML بايد يك برچسب اصلی داشته باشند.
اولين برچسب در يك سند XML، برچسب اصلی است.
همه سندهای XML بايد شامل يك جفت برچسب باشند كه عنصر اصلی را تعريف می كنند، و بقيه عنصرها بايد در درون اين عنصر اصلی قرار بگيرند.

همه عنصرها می توانند زير عنصرهای ديگری داشته باشند، و زير عنصرها بايد به صورت درست در دل عنصر اصلی قرار گرفته باشند:

<root>
<child>
<subchild>...</subchild>
</child>
</root>

انتساب مقادير هميشه بايد در علامت نقل قول باشد
در XML حذف علامت نقل قول های انتساب مقادير اشتباه است.
عناصر XML می توانند انتساب ها را در جفت های name/value داشته باشند، دقيقاُ مثل HTML.
به دو سند XML زير توجه كنيد، اولی نادرست و دومی درست است:

<?xml version="1.0" encoding="ISO-8859-1"?>
<note date=2/2/2002>
<to>Tove</to>
<from>Jani</from>
<heading>Reminder</heading>
<body>Dont forget me this weekend!</body>
</note>

<?xml version="1.0" encoding="ISO-8859-1"?>
<note date="2/2/2002">
<to>Tove</to>
<from>Jani</from>
<heading>Reminder</heading>
<body>Dont forget me this weekend!</body>
</note>

درست: date="2/2/2002" ، نادرست: date=2/2/2002

فضای خالی در XML
در XML فضاهای خالی حذف نميشوند كه اين برعكس HTML است. در HTML يك جمله شبيه:
This is a test كه شامل فضای خالی است، به اين شكل نمايش داده خواهد شد:

This is a test.

CR/LF در XML
در برنامه های تحت ويندوز برای ايجاد خط جديد در متن از جفت كاراكترهای CR/LF استفاده ميشود، اما دربرنامه های Unix برای اين كار فقط از كاراكتر LF استفاده ميشود و در متن قرار می گيرد. در XML نيز از روش دوم استفاده می شود.

توضيحات در XML
XML نيز مانند HTML برای اضافه كردن خط های توضيح مؤلف از روش زير استفاده می كند:

<!--This is a comment-->

همه مقالات سرويس های XML وب را ببينيد.
جستجو: بگرد!
جستجوی پيشرفته
نام کاربری |
کلمه عبور |


IranASP.NET - اجرای ASP روی كامپيوتر خودتان

اجرای ASP روی كامپيوتر خودتان

مسلم ابراهيمی | اين مقاله ۷۳۷۰ بار تاکنون ديده شده است.
۱۳۸۰/۱۲/۱۶ | برای وبلاگ برای وبلاگ
در اين مقاله برای مبتديان روش اجرای ASP و برنامه های مورد نياز توضيح داده شده است.

شما ميتوانيد ASP را روی كامپيوتر خود و بدون احتياج به يك سرور بيرونی نيز اجرا كنيد. برای اين منظور شما بايد يكی از برنامه های PWS يا IIS را روی كامپيوتر خود نصب كنيد.
اگر شما در مورد استفاده از ASP چندان هم جدی نباشيد، حداقل بايد ويندوز98 نسخه دوم را داشته باشيد.
اما اگر واقعاً در مورد استفاده از ASP جدی هستيد و ميخواهيد به صورت حرفه ای از آن استفاده كنيد، بايد از ويندوز 2000 يا ويندوزهای جديدتر استفاده كنيد.

چگونگی نصب PWS و اجرای ASP روی ويندوز 95
برنامه PWS (Personal Web Server) همراه ويندوز 95 ارائه نشده است.
برای اجرای ASP روی ويندوز95 شما می توانيد به اين آدرس برويد.
و Windows NT 4.0 Option Pack را از مايكروسافت دريافت كنيد.

چگونگی نصب PWS و اجرای ASP روی ويندوز NT
برنامه PWS همراه ويندوز NT نيز ارائه نشده است.
برای اجرای ASP روی ويندوزNT شما می توانيد به اين آدرس برويد.
و Windows NT 4.0 Option Pack را از مايكروسافت دريافت كنيد.

چگونگی نصب PWS و اجرای ASP روی ويندوز 98
۱- فلدر Add-ons را از روی cd ويندوز98 بازكنيد و سپس فلدر pws راپيداكنيد و setup.exe را اجرا كنيد.
۲- يك فلدر به اسم Inetpub در هارد درايو شما ايجاد شده، آن را باز كنيد و فلدر wwwroot را پيدا كنيد.
۳- يك فلدر جديد مثلMyWeb در wwwroot ايجاد كنيد.
۴- فايل ASP خود را مانند test1.asp در MyWeb كپی كنيد.
۵- مطمئن بشويد كه وب سرور شما در حال اجرا است.(البته به صورت معمول خود در اين حالت قرار دارد)
۶- جستجوگر خود را باز كرده و آدرس http://localhost/MyWeb/test1.asp را وارد كنيد تا اولين صفحه ASP خود را ببينيد.

چگونگی نصب IIS و اجرای ASP روی ويندوز 2000
۱- از دگمه Start به Settings و بعد به Control Panel برويد.
۲- در پنجره Control Panel ، Add/Remove Programs را انتخاب كنيد.
۳-در پنجره Add/Remove Programs گزينه Add/Remove Windows Components را انتخاب كنيد.
۴- در پنجره Wizard ، Internet Information Services را انتخاب كرده و روی OK كليك كنيد.
۵- يك فلدر به اسم Inetpub در هارد درايو شما ايجاد خواهد شد.
۶- Inetpub را باز كنيد و فلدر wwwroot را پيدا كنيد.
۷- يك فلدر جديد مثلMyWeb در wwwroot ايجاد كنيد.
۸- - فايل ASP خود را مانند test1.asp در MyWeb كپی كنيد.
۹- مطمئن بشويد كه وب سرور شما در حال اجرا است.(البته به صورت معمول خود در اين حالت قرار دارد)
۱۰- جستجوگر خود را باز كرده و آدرس http://localhost/MyWeb/test1.asp را وارد كنيد تا اولين صفحه ASP خود را ببينيد.

چگونگی نصب IIS و اجرای ASP روی Windows XP Professional
توجه: شما نمی توانيد ASP را روی نگارش خانگی XP اجرا كنيد.
۱- از دگمه Start به Settings و بعد به Control Panel برويد.
۲- در پنجره Control Panel ، Add/Remove Programs را انتخاب كنيد.
۳-در پنجره Add/Remove Programs گزينه Add/Remove Windows Components را انتخاب كنيد.
۴- در پنجره Wizard ، Internet Information Services را انتخاب كرده و روی OK كليك كنيد.
۵- يك فلدر به اسم Inetpub در هارد درايو شما ايجاد خواهد شد.
۶- Inetpub را باز كنيد و فلدر wwwroot را پيدا كنيد.
۷- يك فلدر جديد مثلMyWeb در wwwroot ايجاد كنيد.
۸- فايل ASP خود را مانند test1.asp در MyWeb كپی كنيد.
۹- مطمئن بشويد كه وب سرور شما در حال اجرا است.(البته به صورت معمول خود در اين حالت قرار دارد)
۱۰- جستجوگر خود را باز كرده و آدرس http://localhost/MyWeb/test1.asp را وارد كنيد تا اولين صفحه ASP خود را ببينيد.

همه مقالات ASP کلاسيک را ببينيد.
جستجو: بگرد!
جستجوی پيشرفته
نام کاربری |
کلمه عبور |


IranASP.NET - ايجاد يك سيستم كلمه عبور ساده – قسمت ۱

ايجاد يك سيستم كلمه عبور ساده – قسمت ۱

حميد استادهاشمی | اين مقاله ۶۹۶۴ بار تاکنون ديده شده است.
۱۳۸۰/۱۲/۲۲ | برای وبلاگ برای وبلاگ دريافت کد
ايجا يك سيستم Login برای ورود اعضاء يك سايت

امروزه اغلب سايتهايی را كه مشاهده می كنيد معمولا دارای يك سيستم Login هستند كه بوسيله يك شناسه كاربری (UserID) و يك كلمه عبور (Password)، قادر به تشخيص افراد خاصی از ميان تمام مراجعه كنندگان به سايت هستند.

يك نمونه بارز آن صفحه SignIn سايت معروف Yahoo! برای ورود به پست الكترونيك كاربران است كه ياهو پس از بررسی وجود شناسه كاربری و صحت كلمه عبور وارد شده، به كاربران اجازه ورود به صندوق پستی خود را می دهد.

در اين مقاله سعی شده است با ساخت يك برنامه ساده Login توضيحاتی درباره ساختار و نحوه كار آنها بيان نماييم :

قبل از هر چيز ما نياز به ساختن يك بانك اطلاعاتی برای ذخيره كردن اطلاعات كاربران سايت داريم. اين بانك اطلاعاتی می تواند بوسيله برنامه های مختلفی از جمله Access ساخته شود. بانك اطلاعاتی مورد نياز برای اين برنامه شامل يك جدول بنام Members و دو ستون به نامهای UserID وPassword برای ذخيره اطلاعات كاربران است.

همچنين دستور SQL برای ساختن اين جدول در صفحات ASP بصورت زير است:

Create Table Members (
UserID(20)
Password(15)
)

پس از ساختن اين بانك اطلاعاتی نياز به ساخت يك فرم ساده برای دريافت اطلاعات كاربران داريم كه آنرا در داخل صفحه ای بنام Login.htm می سازيم.

اين صفحه به سادگی و بوسيله دستورات مقدماتی HTML قابل تهيه است.

<HTML>
<HEAD><TITLE>Login</TITLE></HEAD>
<BODY>
<TABLE cellSpacing="0" cellPadding="0" border="0" width="300" align="center">
<TR><TD align="center" Colspan="2"><H2>Login Members</H2></TD></TR>
<TR Height="35">
<TD align="right" Width="100">
<FORM Method="post" Action="Login_Action.asp">
UserID&nbsp;:&nbsp;
</TD>
<TD align="Left">
<INPUT type="text" name="UserID" Size="20">
</TD>
</TR>
<TR Height="35">
<TD align="right">
Password&nbsp;:&nbsp;
</TD>
<TD align="left">
<INPUT type="Password" name="Password" Size="20">
</TD>
</TR>
<TR Height="35"><TD align="center" Colspan="2">
<INPUT type="Submit" name="Submit" value="Login">
</TD></TR>
</TABLE>
</FORM>
</BODY>
</HTML>

در كد بالا چند نكته قابل توجه وجود دارد :

Form method=Post: نحوه ارسال اطلاعات فرم را مشخص می كند. بدين صورت كه اگر ما بخواهيم اطلاعات دريافتی از يك كاربر را به صفحه ديگری برای پردازش ارسال كنيم، بايد از اين متد، يعنی متد Post استفاده كنيم. اطلاعاتی كه بوسيله متد Post ارسال می شوند، در صفحه بعدی بوسيله شئ Request و بصورت زير قابل بازيابی هستند.

Request.Form("fieldname")

Action=Login_Action.asp: مقداری كه در مقابل ويژگی Action در دستور Form قرار گرفته، نام فايلی است كه اطلاعات فرم پس از دريافت از كاربر، به آن صفحه ارسال می شود.

ويژگی Name در دستور Input: نام متغيری است كه كلمه ورودی كاربر در فيلد جاری در آن ذخيره می شود. هر كلمه ای كه كاربر در يك فيلد وارد می كند در صفحه مقصد بوسيله نامی كه برای آن فيلد تعيين شده قابل دسترسی است.

پس از ساخت بانك اطلاعاتی و يك فرم ساده برای دريافت اطلاعات كاربران، نوبت به ساخت صفحه ای برای پردازش و پاسخ متقابل به اطلاعات ورودی كاربران است. اين صفحه را با نام Login_Action.asp می سازيم.

<%@Language="VBScript"%>
<%
User = Request.Form("UserID")
Pass = Request.Form("Password")
Set AdoCon = Server.CreateObject("ADODB.Connection")
StrCon = "DRIVER={Microsoft Access Driver (*.mdb)};DBQ=" & Server.MapPath("Users.mdb")
AdoCon.Open StrCon
Set AdoRec = Server.CreateObject("ADODB.Recordset")
StrSQL = "SELECT * FROM Members WHERE UserID ='" & User & "'"
AdoRec.Open StrSQL, StrCon
IF NOT AdoRec.EOF Then
IF Pass = Trim(AdoRec("Password")) Then
Response.Write ("Welcome " & User)
Else
Response.Write ("Invalid Password")
End IF
Else
Response.Write ("Invalid UserID")
End IF
Set AdoCon = Nothing
Set StrCon = Nothing
Set AdoRec = Nothing
%>

همه مقالات ASP کلاسيک را ببينيد.
جستجو: بگرد!
جستجوی پيشرفته
نام کاربری |
کلمه عبور |


IranASP.NET - ايران در جهانی سازی دات نت

ايران در جهانی سازی دات نت

اميد خندان راد | اين مقاله ۵۴۰۸ بار تاکنون ديده شده است.
۱۳۸۰/۱۲/۲۵ | برای وبلاگ برای وبلاگ
بررسی جهانی سازی در دات نت و نقش و موقعيت فعلی ايران در آن

جهانی سازی از ديدگاه‌های مختلف دارای معانی متفاوتی است. در اينجا به اين مقوله از نگاه فنآوری اطلاعات و خصوصاً دات‌نت مي‌پردازيم.

بطور ساده، منظور از جهانی سازی (Globalization) يا بين‌المللی سازی (Internationalization)، طراحی و توليد رابط‌های کاربر(UI)ی است که بتوانند بسته به زبان و مکان استفاده کنندگان مختلف هماهنگ شوند. اين موضوع بخاطر دستيابی به خريداران غيرمحلی و بازارهای جهانی بسيار مورد توجه توليد کنندگان بزرگ دنيا قرار گرفته است. چنين رابط‌های کاربری ممکن است بر روی هر نمايشگری مثل مانيتور، صفحه LCD تلفن‌های همراه يا کامپيوتر‌های جيبی و ... نمايش داده شوند که به آنها چندزبانه نيز مي‌گويند.

واژه‌ی ديگری که در همين ارتباط ممکن است با آن مواجه شويد، محلی سازی (Localization) است. محلی سازی در واقع تغييری است که بر روی يک نرم‌افزار داده مي‌شود تا آن را مناسب محلی بکند که در آنجا استفاده مي‌شود. عمده‌ی مسائلی که در محلی سازی بايد به آنها توجه کرد عبارتند از:

• چگونگی نمايش متون
• چگونگی نمايش تاريخ و ساعت
• چگونگی نمايش اعداد
• مسائل مربوط به پول

در گذشته لازم بود که برنامه نويسان با صرف وقت، هزينه و انرژی نسبتاً زياد که مي‌بايست در کنار مديريتی قوی هدايت مي‌شد، نرم‌افزارهای خود را بصورت محلی در آورند. مخصوصاً برای زبان‌هايی که ريشه‌ی غير لاتين دارند مانند فارسی، اين جريان با مشکلات بيشتری مواجه بود.

جهانی سازی در دات‌نت
خوشبختانه در سالهای اخير با پذيرفته شدن استانداردهای بين‌المللی سازی و تبادل اطلاعات چند زبانه، مانند يوني‌کد، و پشتيبانی شرکت‌ها و صاحبان صنايع IT دنيا از آنها، راه برای جهانی سازی انفورماتيک در حال هموار شدن است. شرکت مايکروسافت نيز با اتخاذ اين استانداردها در پروژه دات‌نتِ خود گام بزرگی در اين جهت برداشته است.

تکنولوژی دات‌نت به عنوان نسل جديد و فراگير IT، جهانی سازی را با نگاهی مساوی به تمامی کشورها و فرهنگ‌های جهان مد نظر قرار داده و با تسهيلاتی که در آن برای برنامه نويسان فراهم آمده به راحتی مي‌توان به توليد و ساخت نرم افزارهای استاندارد چند زبانه و يا محلی شده پرداخت. البته اين ابزار هنوز در حال تکميل است و خالی از اشکال و کاستی نيست.

در شالوده‌ی تکنولوژی دات‌نت ‪(.NET Framework)‬ کلاس‌هايی تعبيه شده که در آنها اطلاعات و مشخصات مربوط به هر کشور و فرهنگ مانند زبان، خط و سيستم نوشتاری، تقويم، روش مرتب سازی و مقايسه‌ی رشته‌های حرفی، واحد پول، سيستم اندازه‌گيری و غيره بطور جداگانه تعريف شده‌اند و از طريق برنامه نويسی قابل دسترس مي‌باشند.

مشخصات کشور ايران در دات‌نت
مشخصات ايران را نيز مي‌توان مانند همه‌ی کشورهای ديگر از اين کلاس‌ها بدست آورد. البته همه‌ی اين اطلاعات کامل نيستند و متأسفانه برخی از آنها بطور ناقص و بعضاً اشتباه وارد شده‌اند. دليل اين امر را بايد در منابعی که مايکروسافت از آنها بهره برده جستجو کرد. کلاس‌های جهانی سازی دات‌نت اگرچه از طرف هيچ سازمانی بعنوان قرارداد پذيرفته نيستند ولی برای برنامه نويسان بيشماری که از آنها استفاده خواهند کرد بعنوان يک مرجع معتبر شناخته مي‌شوند. بنابراين احساس مي‌شود قبل از اينکه اين اطلاعات بخواهند بطور گسترده مورد استفاده توسعه دهندگان وب و نرم‌افزار قرار بگيرند، بايد در اصلاح و تکميل آنها تلاشهايی انجام شود.

در مقالات بعدي به بررسی جزئيات اين مسئله خواهيم پرداخت.

همه مقالات فارسی در وب را ببينيد.
جستجو: بگرد!
جستجوی پيشرفته
نام کاربری |
کلمه عبور |


IranASP.NET - بررسی کلاس Globalization.CultureInfo

بررسی کلاس Globalization.CultureInfo

اميد خندان راد | اين مقاله ۷۱۰۴ بار تاکنون ديده شده است.
۱۳۸۰/۱۲/۲۵ | برای وبلاگ برای وبلاگ دريافت کد
بررسی مشخصات کشور ايران در کلاس CultureInfo

در اين کلاس مشخصات مربوط به فرهنگ‌ ملتها شامل زبان، سيستم نوشتاری، تقويم‌های مورد استفاده و ... ذخيره شده‌اند. طبق توضيحاتی که برای اين کلاس وجود دارد، به هر فرهنگ‌(culture) يک نام بنابه استاندارد RFC 1766 و يک مشخصه‌ی عددی اختصاص داده شده است. مثلاً ايران را مي‌توان با نام "fa-IR" و يا مشخصه‌ی "‪0x0429‬" نشان داد. در اينجا fa-IR يک فرهنگ specific است که دقيقاً زبان و کشور را مشخص مي‌کند. دسته‌ی ديگری از فرهنگ‌ها به نام neutral (يا بيطرف) نيز وجود دارند که فقط زبان را مشخص مي‌کنند و مستقل از يک کشور يا منطقه‌ی خاص هستند. در اين مورد، فارسی با نام "fa" و يا مشخصه‌ی "0x0029" تعريف مي‌شود و به عنوان parent culture برای fa-IR در نظر گرفته مي‌شود.

برای ديدن ليست کامل فرهنگ‌ها مي‌توانيد به صفحه‌ی CultureInfo Class در کتابخانه‌ی MSDN مراجعه کنيد.

مثال: مثال زير اطلاعات مختلف فرهنگ fa-IR را از کلاس CultureInfo استخراج کرده و نمايش مي‌دهد. ‪(C#)‬

<%@ Page language="C#" %>
<%@ Import namespace="System.Globalization" %>
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=utf-8">
</head>
<body>
<h3>
Iran culture information
</h3>
<% CultureInfo ircul = new CultureInfo("fa-IR"); %>
Name:
<% Response.Write(ircul.Name); %>
<br>
Locale Identifier:
<% Response.Write(ircul.LCID); %>
<br>
English Name:
<% Response.Write(ircul.EnglishName); %>
<br>
Dispaly Name (in .NET language):
<% Response.Write(ircul.DisplayName); %>
<br>
Native Name:
<span dir="rtl">
<% Response.Write(ircul.NativeName); %>
</span><br>
Is Neutral Culture:
<% Response.Write(ircul.IsNeutralCulture); %>
<br>
Two-Letter ISO Language Name (ISO 639-1):
<% Response.Write(ircul.TwoLetterISOLanguageName); %>
<br>
Three-Letter ISO Language Name (ISO 639-2):
<% Response.Write(ircul.ThreeLetterISOLanguageName); %>
<br>
Three-Letter Windows Language Name:
<% Response.Write(ircul.ThreeLetterWindowsLanguageName); %>
<br>
Calendar in use (Default Calendar):<br>&nbsp;&nbsp;&nbsp;
<% Response.Write(ircul.Calendar.ToString()); %>
<br>
Optional Calendars (All Calendars in use):
<br>
<% foreach (System.Globalization.Calendar cal in ircul.OptionalCalendars) {
Response.Write("&nbsp;&nbsp;&nbsp;" + cal.ToString() + "<br>");
}
%>
</body>
</html>

خروجی اين برنامه بصورت زير است که در ادامه در مورد آن توضيح خواهم داد:

Iran culture information
Name: fa-IR
Locale Identifier: 1065
English Name: Farsi (Iran)
Dispaly Name (in .NET language): Farsi (Iran)
Native Name: فارسى (ايران)
Is Neutral Culture: False
Two-Letter ISO Language Name (ISO 639-1): fa
Three-Letter ISO Language Name (ISO 639-2): fas
Three-Letter Windows Language Name: FAR
Calendar in use (Default Calendar):
System.Globalization.GregorianCalendar
Optional Calendars (All Calendars in use):
System.Globalization.GregorianCalendar
System.Globalization.GregorianCalendar
System.Globalization.HijriCalendar
System.Globalization.GregorianCalendar

در اين مثال، برای ايجاد شئ ircul مي‌توانيد بجای new CultureInfo("fa-IR")‎ از سازنده‌ی new CultureInfo(0x0429)‎ هم استفاده کنيد.

Locale Identifier همان مشخصه‌ی عددی فرهنگ است که با ارجاع به CultureInfo.LCID بدست مي‌آيد.

چيز جالبی که در اينجا مي‌توانيد ببينيد، خروجی دستور ircul.NativeName است که يک عبارت فارسی ست بصورت "فارسى (ايران)". البته يک ايراد کوچک در آن وجود دارد: يای آخر در کلمه‌ی "فارسي" دارای کد U+0649 (الف مکسورة) و يای وسط در کلمه "ايران" دارای کد U+064A (يای عربی) مي‌باشد که طبق قوانين يوني‌کد برای زبان فارسی هردوی آنها بايد کد U+06CC (يای فارسی) را داشته باشند.

نکته‌ی ديگری که در اينجا وجود دارد، ترجمه‌ی لفظی کلمه‌ی "فارسي" يعنی "Farsi" است که با فراخوانی ircul.EnglishName بدست مي‌آيد. اين کلمه که علاوه بر دات‌نت در يوني‌کد و استانداردهای W3C نيز بکار رفته، اصولاً در زبان انگليسی درست نيست. توضيح اين مطلب را به نقل از نوشته‌ی دوست عزيزم آقای خداداد رضاخانی (ايرانشناس) مي‌نويسم:

[فارسی تلفظ عربی پارسی است که اسم زبان ماست. در زبانهای اروپايی اين کلمه از يونانی گرفته شده که بصورت صحيح و با "پ" بجای "ف" است. اما اينکه چرا بعضي‌ها می گويند Farsi بجای استفاده از Persian که صورت درست کلمه است، [...]! Farsi اسم زبان ماست در فارسی، اما در انگليسی و زبانهای ديگر اروپايی بايد گفت Persian/Persisch/Persan . مثل اينکه در انگليسی، اسم زبان English است و در فارسی ما "انگليسي" می گوييم. اگر کسی بگويد "من انگليش صحبت می کنم"، کلمه اشتباهی بکار برده. کما اينکه يونانی ها به زبانشان Elliniki می گويند، اما در انگليسی از Greek استفاده می کنند. ايرانيان هم بايد ياد بگيرند که به قوانين زبانها احترام بگذارند و از کلمات صحيح استفاده کنند].

بنابراين خروجی ircul.EnglishName بايد بصورت "Persian (Iran)‎" باشد.

در مورد تقويم‌های مورد استفاده در ايران، همانطور که ملاحظه مي‌کنيد، تقويم هجري-شمسی ديده نمي‌شود. تقويم‌های نسبت داده شده به کشور ايران طبق خروجی برنامه فوق سه تا GregorianCalendar (تقويم ميلادی) و يک HijriCalendar (تقويم هجري-قمری) است. تقويم ميلادی در System.Globalization برگردان‌های مختلفی دارد که در فهرست Globalization.GregorianCalendarTypes ليست شده‌اند. با دستورهای زير مشخص مي‌شود که هر يک از اين تقويم‌های ميلادی از کدام نوع آن است:

Response.Write(((GregorianCalendar)ircul.Calendar).CalendarType);
OUTPUT-> Localized

Response.Write(((GregorianCalendar)ircul.OptionalCalendars[0]).CalendarType);
OUTPUT-> USEnglish
Response.Write(((GregorianCalendar)ircul.OptionalCalendars[1]).CalendarType);
OUTPUT-> Localized
Response.Write(((GregorianCalendar)ircul.OptionalCalendars[3]).CalendarType);
OUTPUT-> TransliteratedEnglish

برگردان‌های مختلف تقويم ميلادی در کلاس DateTimeFormatInfo استفاده مي‌شوند و برای اين هستند که بتوانيم تاريخ را در آن در مدلهای مختلف نشان دهيم. مثلاً در تقويم پيش‌فرض که در اينجا مي‌بينيد، يعنی Localized که در واقع برگردان فرانسوی تقويم ميلادی است، ماهها بشکل : ژانويه، فوريه، مارس، آوريل، مى، ژوئن، ژوئيه، اوت، سپتامبر، اُكتبر، نوامبر، دسامبر نشان داده مي‌شوند و در برگردان انگليسی (TransliteratedEnglish) ماهها بشکل يناير، فبراير، مارس، ابريل، مايو، يونيو، يوليو، اغسطس، سبتمبر، اكتوبر، نوفمبر، ديسمبر نشان داده مي‌شوند که البته اين برگردان از انگليسی به عربی است و در فارسی چنين چيزی نداريم. به نظر من بهترين خروجی که propertyی ircul.OptionalCalendars مي‌تواند داشته باشد آرايه‌ايست که اعضای آن به ترتيب تقويم ميلادی (انگليسی)، تقويم هجری شمسی (جلالی)، تقويم ميلادی (برگردان فرانسوی) و تقويم هجری (قمری) باشد.

از کلاس CultureInfo علاوه بر اطلاعات فوق مي‌توان سه کلاس ديگر به نامهای DateTimeFormatInfo، NumberFormatInfo و TextInfo را نيز استخراج کرد که هرکدام اطلاعات ديگری را که از اسم آنها مشخص است در اختيارمان قرار مي‌دهند که اگر فرصت پيدا کنم راجع به هرکدام جداگانه توضيح خواهم داد.

برای نشان دادن فرهنگ جاری سيستم که در Control Panel ويندوز تنظيم شده مي‌توانيد از دستور زير استفاده کنيد:

Response.Write( CultureInfo.CurrentCulture.Name );

در بخش سوم اين سری مقالات در مورد تقويم هجري-شمسی صحبت خواهم کرد.

همه مقالات فارسی در وب را ببينيد.
جستجو: بگرد!
جستجوی پيشرفته
نام کاربری |
کلمه عبور |


IranASP.NET - درس هشتم: آشنائی با شئ Application

درس هشتم: آشنائی با شئ Application

محمد جواد سخائی | اين مقاله ۴۱۱۶ بار تاکنون ديده شده است.
۱۳۸۰/۹/۱۷ | برای وبلاگ برای وبلاگ
کاربرد شئ Application و نحوه تعريف و بکارگيری متغير در آن

مجموعه ای از فايل های ASP كه بمنظور نيل به يك هدف خاص در كنار هم قرار می گيرند، يك برنامه ( Application ) را بوجود می آورند. شئ Application بمنظور تاثيرگذاری در نحوه ارتباط فايل های تشكيل دهنده يك برنامه استفاده می گردد. از شئ فوق بمنظور ذخيره سازی متغيرها و دستيابی به آنها از طريق هر يك از صفحات ASP موجود در يك برنامه استفاده می گردد ( مانند شئ Session ) . تفاوت اين شئ با شئ Session در اين است كه تمامی كاربران از يك شئ Application بصورت مشترك استفاده می كنند در صورتيكه شئ Session به ازای هر كاربر ايجاد و مقادير مورد نظر در رابطه با آن كاربر بخصوص را در خود نگهداری می كند.

شئ Application می بايست اطلاعاتی را در خود نگهداری نمايد كه در بالاترين سطح دسترسی در يک برنامه تحت وب قرار دارند. بعبارت ديگر شئ Application دربردارنده متغيرهای عمومی است که همه جلسات کاری کاربران از ابتدای اجرا تا پايان يک برنامه تحت وب، با آن متغيرها سروکار دارند ( نظير دستيابی مشترك به مسير يا کلمه عبور يك بانك اطلاعاتی). اين بدين معنی است كه ما می توانيم به اطلاعات ذخيره شده در شئ فوق از طريق هر يك از صفحات، دسترسی داشته باشيم. به عبارت ديگر می توان اطلاعات را از يك محل تغيير و اثر آن را از طريق صفحات ديگر مشاهده و استفاده نمود.

ذخيره و بازيابی مقادير متغير
شئ Application می بايست در فايل Global.asa ايجاد گردد. پس از ايجاد شئ فوق امكان دستيابی و تغيير در اطلاعات آن برای هر يك از صفحات موجود در يك برنامه فراهم می گردد. مثال زير نحوه ايجاد شئ فوق را در فايل Global.asa نشان ميدهد:

<Script Language="VBScript" Runat="Server">
Sub Application_OnStart
Application("DBDriver")="Microsoft.Jet.OLEDB.4.0"
Application("ActiveUsers")=1
End Sub
</Script>

در مثال فوق، دو متغير Application ايجاد شده است. اولين متغير با نام DBDriver و دومين متغير با نام ActiveUsers است. جهت دستيابی به مقادير اين دو متغير از روش زير می توان استفاده كرد.

There are <%Response.Write(Application("ActiveUsers"))%> active connections.

بكمك يك حلقه تكرار و دستيابی به مجموعه Contents ، می توان مقادير شئ فوق را مشاهده نمود.

<%
Dim i
For Each i in Application.Contents
Response.Write(Application.Contents(i) & "<br>")
Next
%>

در صورتيكه شناخت لازم در رابطه با تعداد آيتم های ذخيره شده در شئ فوق را نداشته باشيم، می توان از ويژگی Count استفاده نمود.

<%
Dim i
Dim j
j=Application.Contents.Count
For i=1 to j
Response.Write(Application.Contents(i) & "<br>")
Next
%>

قفل نمودن يك برنامه
با استفاده از متد Lock ، می توان يك برنامه را قفل نمود. زمانيكه يك برنامه قفل می گردد، كاربران قادر به تغيير متغيرهای شئ Application نخواهند بود. در چنين حالتی تنها يك ارتباط فعال با شئ فوق وجود خواهد داشت. جهت بازنمودن قفل می توان از متد Unlock استفاده كرد.

<%
Application.Lock
'do some application object operations
Application.Unlock
%>

کاربرد اين امکان برای جلوگيری از دسترسی همزمان هنگام تغيير يک متغير از نوع Application است. بعبارت ديگر بهتر است عادت کنيم که هنگام تغيير در متغيرهای از نوع Application ، همواره قبل از انجام تغيير، برنامه را قفل کرده و در اولين فرصت پس از عبور از ناحيه بحرانی، قفل برنامه را باز کنيم. اين روش سبب اطمينان از مقدار اين نوع متغيرها شده و از خطاهای منطقی و غيره جلوگيری می نمايد.

همه مقالات ASP کلاسيک را ببينيد.
جستجو: بگرد!
جستجوی پيشرفته
نام کاربری |
کلمه عبور |


IranASP.NET - کنترل های HTML

کنترل های HTML

مديريت سايت | اين مقاله ۴۹۳۲ بار تاکنون ديده شده است.
۱۳۸۰/۹/۲۴ | برای وبلاگ برای وبلاگ دريافت کد
دريافت اطلاعات ورودی و بررسی کنترل های HTML در ASP.NET

در يک صفحه ASP.NET می توان دو نوع کنترل داشت: کنترل های HTML و کنترل های Web. کنترل های HTML جهت ايفای نقش همان تگ های HTML معمولی طراحی شده اند. بعبارت ديگر اگر يک صفحه HTML معمولی داشته باشيم، با تبديل تگ های مربوطه به کنترل های HTML می توانيم سريعا آن را به يک صفحه ASP.NET تبديل کنيم.

بعنوان مثال صفحه ساده HTML زير را در نظر بگيريد. اين صفحه حاوی يک فرم است که شما را قادر می سازد تا مثلا رنگ دلخواه خود را در آن وارد کنيد.

<html>
<head><title>SimpleHTML.htm</title></head>
<body>

<form method="post" action="SimpleHTML.htm">

Enter your favorite color:
<br>
<input name="favColor" type="text">
<p>
<input type="submit" value="Submit!">

</form>

</body>
</html>

اگر رنگ لخواه خود را وارد کرده و دکمه ارسال فرم را بزنيد، اتفاق خاصی نخواهد افتاد چرا که فرم تنها اطلاعات وارد شده را به خود برمی گرداند و از آنجا که پس از ارسال فرم، پردازشی روی اطلاعات ورودی انجام نمی شود، ورودی مذکور از بين می رود.

در مثال زير صفحه فوق به يک صفحه ASP.NET تبديل شده است.

<html>
<head><title>SimpleASPX.aspx</title></head>
<body>

<form runat="server">

Enter your favorite color:
<br>
<input id="favColor" type="text" runat="server">
<p>
<input type="submit" value="Submit!" runat="server">

</form>

</body>
</html>

همانگونه که مشاهده می کنيد چهار تغيير اساسی و مهم نسبت به صفحه HTML مثال قبل صورت گرفته است:

• پسوند فايل به aspx تغيير کرده است.
• مشخصه runat="server" به همه عناصر فرم موجود اضافه شده است.
• بجای مشخصه name از مشخصه id در تگ <input> استفاده شده است.
• مشخصه های Method و Action از تگ <form> حذف شده اند زيرا فرم های ASP.NET بصورت پيش فرض به همان صفحه ارسال می شوند و ديگر نيازی به مشخصه های فوق نيست.

اگر مثال فوق را اجرا کنيد خواهيد ديد که پس از ارسال فرم و نمايش مجدد صفحه فوق، رنگ مورد نظرتان در قسمت ورودی همچنان موجود است. بعبارت ديگر برعکس HTML معمولی، کنترل های HTML در ASP.NET مقادير خود را بصورت خودکار در استفاده های بعدی حفظ می کنند.

همه مقالات فرم های وب را ببينيد.
جستجو: بگرد!
جستجوی پيشرفته
نام کاربری |
کلمه عبور |


IranASP.NET - کنترل های وب در ASP.NET

کنترل های وب در ASP.NET

مديريت سايت | اين مقاله ۴۷۵۱ بار تاکنون ديده شده است.
۱۳۸۰/۱۰/۱ | برای وبلاگ برای وبلاگ دريافت کد
دريافت اطلاعات از ورودی و بررسی کنترل های وب در ASP.NET

HTML در طول زمان تکميل شده و به شکل امروزی رسيده است و تاکنون چندين بار ترميم شده است. لذا اگر دقت کنيد متوجه می شويد در برخی موارد، HTML آن حس واقعی از کنترل های واسط کاربری را به انسان نمی دهد. بعبارت ديگر در HTML با استفاده از يک تگ مانند <select> می توان دو نوع واسط کاربری متفاوت مانند ListBox و ComboBox ساخت، در حاليکه برای ساخت دو نوع واسط کاربری از يک جنس مانند InputLine و TextBox نياز به دو تگ متفاوت <input> و <textarea> داريم.

در ASP.NET سعی شده است که اين نقيصه بنوعی برطرف گردد. در ASP.NET جهت ساخت واسط کاربری، عناصر متعددی در نظر گرفته شده است که کنترل های وب نام دارند. اين کنترل ها در مرحله برنامه نويسی کاملا با تگ های HTML متفاوتند اما در مرحله اجرا، اين کنترل ها به تگ های معادل و معمولی در HTML تبديل می شوند. در زير برخی کنترل های وب رايج و پايه ای در ASP.NET معرفی می گردد:

• TextBox : جهت دريافت وروديهای متنی (تايپی) بصورت تک خط يا چند خط و نيز کلمه عبور.
• Label : جهت نمايش برچسب و عبارات متنی ثابت و نمايشي.
• CheckBox : جهت ورودی های از نوع فعال / غيرفعال.
• RadioButton : جهت ورودی های انتخابی از ميان چندين گزينه.
• HyperLink : جهت نمايش و ساخت پيوند يا اتصال (لينک) به ديگر صفحات.
• Button : جهت ساخت يک دکمه يا کليد برای ارسال يک فرم HTML جهت پردازش به سرور يا انجام عمل خاصي.
• LinkButton : جهت ساخت پيوندی که با فشردن آن يک فرم HTML جهت پردازش به سرور ارسال می گردد.
• ImageButton : جهت ساخت يک دکمه تصويری که با فشردن آن يک فرم HTML جهت پردازش به سرور ارسال می گردد.

کاربرد اين کنترل ها در يک صفحه مانند تگ های HTML است. يعنوان مثال، در صفحه ASP.NET زير، دو کنترل از نوع TextBox و يک کنترل از نوع Button در يک فرم تعريف شده اند.

<html>
<head><title>Guestbook.aspx</title></head>
<body>

<h3>Please Sign Our Guestbook!</h3>

<form runat="Server">

Your Name:
<br>
<asp:TextBox
ID="username"
runat="Server" />
<p>

Comments:
<br>
<asp:TextBox
ID="comments"
TextMode="Multiline"
Columns="50"
Rows="4"
runat="Server" />

<p>
<asp:Button
Text="Submit!"
Runat="Server" />

</form>

</body>
</html>

در نگاه اول شايد ترکيب استفاده از کنترل های وب در يک صفحه برای شما نامأنوس باشد. اما اگر دقت کنيد متوجه می شويد که استفاده از اين کنترل ها چندان هم مشکل نيست. بعنوان مثال اولين کنترل TextBox جهت دريافت اسم کاربری بصورت زير تعريف شده است.

<asp:TextBox
ID="username"
runat="Server" />

دقت داشته باشيد که برای تعريف صحيح يک کنترل وب بايد سه مورد زير را در نظر گرفت:

• تعيين نوع کنترل (TextBox ، Label ، ...)
• يک نام منحصربفرد در صفحه با استفاده از مشخصه ID
• عبارت runat="Server" جهت تعيين اينکه اين کنترل از نوع کنترل های وب است و هنگام اجرا بايد ابتدا برروی سرور به تگ معادل HTML تبديل شود.

همه مقالات فرم های وب را ببينيد.
جستجو: بگرد!
جستجوی پيشرفته
نام کاربری |
کلمه عبور |


IranASP.NET - درس يازدهم: تشخيص مشخصات کاربر

درس يازدهم: تشخيص مشخصات کاربر

محمد جواد سخائی | اين مقاله ۶۸۵۴ بار تاکنون ديده شده است.
۱۳۸۰/۱۰/۴ | برای وبلاگ برای وبلاگ دريافت کد
تشخيص نوع مرورگر، سيستم عامل و IP كاربران اينترنت و ساير اطلاعات مرتبط

مرورگرها برنامه هائی هستند كه كاربران اينترنت با استفاده از آنان قادر به استفاده از وب سايت ها و منابع موجود در آنها می باشند. جايگاه اين نوع از برنامه ها در يك نرم افزار تحت وب يا اينترنت بسيار حائز اهميت بوده چراكه مسئوليت ايجاد محيط لازم جهت ارتباط با كاربران بر عهده آنها سپرده شده است.

مرورگرها درخواست كاربران را بر اساس پروتكل HTTP برای سرويس دهنده وب ارسال می دارند. پروتكل فوق زبان گفتمان مشترك بين مرورگران وب بعنوان متقاضيان و سرويس دهندگان وب بعنوان پاسخ دهندگان به درخواست ها است. مرورگرها دارای امكانات و پتانسيل های زيادی بوده و در فرآيند پياده سازی يك برنامه تحت وب يا اينترنت نمی توان از كنار آنها بسادگی گذشت. با شناخت پتانسيل ها و نوع رفتار يك مرورگر طراحان نرم افزارهای اينترنت قادر به خلق آثار ارزشمند و پويائی خواهند بود كه قطعا در استمرار موفقيت يك نرم افزار از نقطه نظر جذب مخاطبان خود تاثير گذار خواهد بود. بهرحال صفحات وب درخواستی كاربران اينترنت از طريق اين نوع نرم افرارها به نمايش درخواهد آمد.

يكی از مشكلات موجود در رابطه با طراحی صفحات وب، استفاده از مرورگرهای گوناگون توسط كاربران اينترنت است. در اين رابطه عمده رقابت بين دو مرورگر متعلق به شركت های ماكروسافت (IE يا Internet Exploere) و نت اسكيپ (Netscape) است. استانداردهای تعريف شده توسط هر يك از مرورگرهای فوق با يكديگر متفاوت است. مثلا مرورگر شركت ماكروسافت از كنترل های اكتيوايكس (ActiveX) و زبان Vbscript بعنوان زبان پيش فرض بر روی مرورگرها جهت تزريق توان عملياتی بر روی سرويس گيرندگان استفاده می كند در حاليكه مرورگر شركت نت اسكيپ از زبان جاوااسكريپت بعنوان پيش فرض در اين زمينه استفاده و امكان استفاده از كنترل های اكتوايكس نيز صرفا از طريق نصب يك Plug-in امكان پذير خواهد بود.

پروتكل ها و انشعابات لازم در خصوص بكارگيری HTML پويا (DHTML) و Cascading Style Sheet يا CSS در هر يك از مرورگرهای فوق شرايط خاص خود را دارد. بهرحال آگاهی از نوع مرورگر بخدمت گرفته شده توسط يك كاربر اينترنت و پارامترهای مهم آن در پياده سازی يك سايت موفق و با توجه به طيف گسترده كاربران اينترنت بسيار حائز اهميت خواهد بود. مثلا در صورتيكه يك صفحه وب را با استفاده از DHTML طراحی كرده باشيم و مرورگر ملاقات كننده سايت امكان استفاده از اين ويژگی را نداشته باشد تكليف چيست؟ در اين زمينه شايد بهترين روش پس از تشخيص نوع مرورگر كاربر مورد نظر، ارجاع آن به صفحه ای ديگر است كه همان امكانات را در اختيار وی بدون استفاده از تگ های DHTML بدهد.

فراموش نكنيم كه تعداد و نوع مرورگرهائی كه امروزه توسط كاربران اينترنت استفاده می شود به دو نمونه گفته شده ختم نشده و مرورگرهای WebTV Browser،AOL custom Browser،Lynx ( يك مرورگر متنی تحت يونيكس ) و Opera نمونه های ديگری از دنيای وسيع مرورگرها می باشند.

مرورگرها در زمان درخواست يك صفحه از يك وب سايت، اطلاعاتی نيز راجع به خود بهمراه درخواست ارسال ميدارند اين اطلاعات با عنوان User-Agent String معرفی شده و شامل نوع و نسخه مرورگر و سيستم عامل مربوطه است. اين اطلاعات در مجموعه ServerVariables و تحت نام متغيری با نام HTTP_USER_AGENT قرار خواهند گرفت. اطلاعات ذخيره شده در مجموعه ServerVariables بسيار وسيع بوده و در اين مقاله به بررسی آندسته از اطلاعاتی كه به موضوع مقاله مرتبط است خواهيم پرداخت.

مثال ۱ - در اين مثال با استفاده از مجموعه Server Variables وابسته به شی Request، نوع مرورگر، سيستم عامل و IP ملاقات كننده سايت تشخيص داده می شود. ( در مثال می توان برخی از مقايسه ها را در صورت ضرورت حذف نمود و برنامه را برای موارد خاص نوشت)

<%
ua = Request.ServerVariables("HTTP_USER_AGENT")
os = Request.ServerVariables("HTTP_UA_OS")
If Instr(ua, "MSIE") Then
If Instr(ua, "MSIE 5.") Then
Browser = "Microsoft Internet Explorer 5.x"
Elseif Instr(ua, "MSIE 4.") Then
Browser = "Microsoft Internet Explorer 4.x"
Elseif Instr(ua, "MSIE 3.") Then
Browser = "Microsoft Internet Explorer 3.x"
If Instr(ua, "MSIE 3.02") Then
Browser = "Microsoft Internet Explorer 3.02"
End If
Else
Browser = "Microsoft Internet Explorer"
End If
ElseIf Instr(ua, "Mozilla") and Instr(ua, "compatible") = 0 Then
If Instr(ua, "Mozilla/4") Then
Browser = "Netscape Navigator 4.x"
Elseif Instr(ua, "Mozilla/3") Then
Browser = "Netscape Navigator 3.x"
Else
Browser = "Netscape Navigator"
End If
End If
If Instr(ua, "Windows 95") or Instr(ua, "Win95") Then
System = "Windows 95"
Elseif Instr(ua, "Windows 98") or Instr(ua, "Win98") Then
System = "Windows 98"
Elseif Instr(ua, "Windows 3.1") or Instr(os, "Win16") Then
System = "Windows 3.x/Windows NT 3.x"
Elseif Instr(ua, "NT") or Instr(ua, "NT") Then
System = "Windows NT"
Elseif Instr(ua, "Mac") Then
System = "Mac"
If Instr(ua, "PowerPC") or Instr(ua, "PPC") Then
System = "Mac PPC"
Elseif Instr(ua, "68000") or Instr(ua, "68K") Then
System = "Mac 68K"
End If
Elseif Instr(ua, "X11") Then
System = "UNIX"
End If
%>
You are using <%=Browser%><br>
You are using : <%=System%> operating system<br>
Your IP is: <%=Request.ServerVariables("Remote_Addr")%>

مثال ۲ - در اين مثال با استفاده ازمجموعه Server Variables وابسته به شی Request، اطلاعاتی نظير نام سرويس دهنده، زبان مرورگر، و ساير اطلاعات ذيربط نمايش داده می شود.

your Server name is <%=Request.ServerVariables("Server_Name")%><br>
your browser language is <%=Request.ServerVariables("HTTP_Accept_Language")%><br>
your server ip is <%=Request.ServerVariables("Remote_Host")%><br>
your local address is <%=Request.ServerVariables("Local_Addr")%><br>
your path info is <%=Request.ServerVariables("Path_Info")%><br>
your server port is <%=Request.ServerVariables("Server_Port")%><br>
your path translated is <%=Request.ServerVariables("Path_Translated")%>

مثال ۳ - در اين مثال پس از نمايش محتويات رشته HTTP_USER_AGENT، امكان ارتقای مرورگر برای كاربران از طريق سايت ماكروسافت فراهم شده و در صورتيكه نسخه مرورگر IE بيشتر از چهار باشد، به آنها اعلام خواهد شد كه امكان استفاده از تگ های DHTML را دارا خواهند بود.

<%
UA = Request.ServerVariables("HTTP_USER_AGENT")
Response.Write " The User Agent String is <b> " & UA & "</B><p>"
If Instr(UA, "MSIE") Then
Response.Write " To Upgrade your browser go to " & "<A HREF=" & chr(34) & "http://www.microsoft.com/ie/" & chr(34) & " >http://www.microsoft.com/ie/</A></P>"
BrowserVersion = Cint(MID(UA, Instr(UA, "MSIE") + 5, 1))
If BrowserVersion >= 4 Then
Response.Write " You can use Microsoft Dynamic HTML "
End If
End If
%>

پس از تشخيص نسخه مرورگر می توان آنها را به صفحات ديگر Redirect نمود. در صورت افزودن دستورات زير به برنامه فوق، در صورتيكه نسخه مرورگر چهار به بعد باشد، default.asp موجود در فهرست DHTMLSupport اجرا شده و در صورتيكه كاربر از مرورگری استفاده می كند كه نسخه آن از چهار كمتر می باشد و با توجه به اينكه اين نسخه ها، امكان DHTML را دارا نمی باشند، برای اين كاربر بخصوص default.asp را از فهرست NonDHTML فعال خواهيم كرد.

If BrowserVersion >= 4 Then
Response.Redirect "/DHTMLSupport/default.asp"
Else
Response.Redirect "/NonDHTML/default.asp"
End If

همه مقالات ASP کلاسيک را ببينيد.
جستجو: بگرد!
جستجوی پيشرفته
نام کاربری |
کلمه عبور |


IranASP.NET - رويدادهای يک صفحه ASP.NET

رويدادهای يک صفحه ASP.NET

مديريت سايت | اين مقاله ۶۴۰۴ بار تاکنون ديده شده است.
۱۳۸۰/۱۰/۲۹ | برای وبلاگ برای وبلاگ دريافت کد
بررسی مجموعه رويدادهايی که هنگام فراخوانی يک صفحه ASP.NET روی می دهند مانند Init و Load...

هنگامی که يک صفحه ASP.NET فراخوانی شود مجموعه رويدادهای زير به ترتيب رخ می دهند:

• Init: اولين رويدادی که هنگام فراخوانی صفحه انجام می گردد.
• Load: اين رويداد قبل از همه رويدادهای مربوط به کنترل های موجود درون صفحه رخ می دهد.
• PreRender: اين رويداد بعد از همه رويدادهای مربوط به کنترل های موجود درون صفحه رخ می دهد.
• Unload: هنگامی که صفحه از حافظه تخليه می گردد اين رويداد رخ می دهد.
• Disposed: اين رويداد بعد از آزاد سازی حافظه از صفحه روی می دهد.

جهت رسيدگی به اين رويدادها می توان برای هر يک، روال مجزائی نوشت. بعنوان مثال روال رسيدگی کننده به رويداد Load می تواند مانند زير باشد:

<Script Runat="Server">

Sub Page_Load
' Place any code that you want to execute here
End Sub
</Script>

توجه داشته باشيد که شما با ايجاد روالی بنام Page_Load می توانيد به رويداد Load مربوط به يک صفحه رسيدگی کنيد. بعبارت ديگر جهت رسيدگی به رويدادهای Disposed ،Unload ،PreRender ،Load ،Init بايد از روال هايی با نامهای Page_Unload ،Page_PreRender ،Page_Load ،Page_Init و Page_Disposed استفاده نمود.

معمولا مفيدترين رويداد يک صفحه رويداد Load می باشد. بعبارت ديگر از اين رويداد جهت مقداردهی به کنترل های موجود درون صفحه استفاده می گردد. برای مثال، مقداردهی يک برچسب يا مقداردهی يک کنترل DataGrid با داده های يک بانک اطلاعاتی در اين رويداد انجام می شود.

مهمترين تفاوت ميان رويدادهای Load و PreRender اين است که رويداد Load قبل از همه رويدادهای مربوط به کنترل های درون صفحه انجام می شود. جهت روشن شدن مطلب به مثال زير توجه فرمائيد. اين صفحه دارای سه رويداد Button_Click ،Page_Load و Page_PreRender می باشد. اگر بر روی دکمه موجود کليک شود ابتدا روال Page_Load، بعد روال Button_Click و در نهايت روال Page_PreRender اجرا می گردد.

<Script Runat="Server">

Sub Page_Load
Response.Write( "<li> Page_Load" )
End Sub

Sub Button_Click( s As Object, e As EventArgs )
Response.Write( "<li> Button_Click" )
End Sub

Sub Page_PreRender
Response.Write( "<li> Page_PreRender" )
End Sub

</Script>

<html>
<head><title>EventOrder.aspx</title></head>
<body>

<form runat="Server">

<asp:Button
Text="Click Here!"
OnClick="Button_Click"
Runat="Server" />

</form>

</body>
</html>

همه مقالات کليات ASP.NET را ببينيد.
جستجو: بگرد!
جستجوی پيشرفته
نام کاربری |
کلمه عبور |


IranASP.NET - کنترل Label يا برچسب

کنترل Label يا برچسب

مديريت سايت | اين مقاله ۴۲۱۱ بار تاکنون ديده شده است.
۱۳۸۰/۱۱/۶ | برای وبلاگ برای وبلاگ دريافت کد
نمايش متن يا برچسب با استفاده از کنترل Label و تعيين رنگ، فونت و ساير مشخصات آن

جهت نمايش متون ثابت در يک صفحه ASP.NET از طريق برنامه می توان از کنترل Label يا برچسب استفاده نمود. برای اين منظور متنی که به صفت Text اين کنترل منسوب گردد توسط اين کنترل نمايش داده می شود. مثال زير نحوه مقدار دهی يک کنترل برچسب با تاريخ روز در هنگام بارگذاری يک صفحه با استفاده از رويداد Page-Load را نشان می دهد.

<Script runat="Server">

Sub Page_Load
lblDate.Text = Now.ToString( "D" )
End Sub

</Script>

<html>
<head><title>ShowDate.aspx</title></head>
<body>

<asp:Label
id="lblDate"
Runat="Server" />

</body>
</html>

جهت نمايش متن مورد نظر با مشخصات دلخواه مانند رنگ، پس زمينه، فونت و غيره می توان از کليه خواص پايه ای کنترل های وب در اين زمينه بهره جست. بعنوان مثال صفحه زير تاريخ روز را با رنگ آبی در پس زمينه زرد با شکل فونت Verdana در اندازه 24p نشان می دهد.

<Script runat="Server">

Sub Page_Load
lblDate.Text = Now.ToString( "D" )
End Sub

</Script>

<html>
<head><title>LabelFormat.aspx</title></head>
<body>

<asp:Label
id="lblDate"
ForeColor="Blue"
BackColor="Yellow"
Font-Name="Verdana"
Font-Size="24pt"
Runat="Server" />

</body>
</html>

همه مقالات فرم های وب را ببينيد.
جستجو: بگرد!
جستجوی پيشرفته
نام کاربری |
کلمه عبور |


IranASP.NET - بررسی شئ Application

بررسی شئ Application

حميد استادهاشمی | اين مقاله ۴۳۸۶ بار تاکنون ديده شده است.
۱۳۸۰/۱۱/۱۶ | برای وبلاگ برای وبلاگ
بررسی مجموعه ها، متدها و رويدادهای شئ Application در ASP كلاسيك

اين مقاله بطور خلاصه به بررسی شئ Application ومتدها، مجموعه هاو رويدادهای آن می پردازد. همانطور كه ميدانيد اين شئ برای ذخيره كردن متغيرها و همچنين دستيابی به متغيرها از هر صفحه ASP استفاده می شود. اين شئ، يك شئ عمومی است و اطلاعاتی را كه می خواهيد در چند صفحه ASP مورد استفاده قرار دهيد، بايد در اين شئ ذخيره كنيد.

مجموعه Contents
اين مجموعه حاوی تمام آيتم های اضافه شده در يك اسكريپت واقع در يك برنامه ASP است. لازم به ذكر است كه برای حذف آيتم ها از اين مجموعه می توانيد از متدهای Remove و Removeall استفاده كنيد.
قاعده تركيبی : Application.Contents(Key)
پارامتر key نام آيتم بازيافت شده از اين مجموعه است.

date")="2001/05/05"
Application("author")="Ostadhashemi"
for each x in Application.Contents
Response.Write(x & "=" & Application.Contents(x) & "<br>")
next
%>

مجموعه StaticObjects
اين مجموعه محتوی تمام آيتم های اضافه شده در يك برنامه ASP است كه بوسيله دستور <Object> اضافه شده اند.
قاعده تركيبی : Application.StaticObjects(Key)
پارامتر key نام آيتم بازيافت شده از اين مجموعه است.

server" scope="application" id="MsgBoard" progid="msgboard.MsgBoard">
</object>
<object runat="server" scope="application" id="AdRot" progid="MSWC.AdRotator">
</object>

In an ASP file :
<%
for each x in Application.StaticObjects
Response.Write(x & "<br>")
next
%>

متد Remove
وظيفه اين متد حذف يك يا چند آيتم از مجموعه Contents است.
قاعده تركيبی : Application.Contents.Remove(name|index)
پارامترها :
name = نام آيتم موجود در مجموعه Contents
index = شماره آيتم موجود در فهرست مجموعه Contents

test1")=("First test")
Application("test2")=("Second test")
Application.Contents.Remove(2)
for each x in Application.Contents
Response.Write(x & "=" & Application.Contents(x) & "<br>")
next
%>

متد RemoveAll
اين متد تمام آيتم های موجود در مجموعه Contents را پاك می كند.
قاعده تركيبی : Application.Contents.RemoveAll()
اين متد، مستقل و بصورت زير در صفحات ASP استفاده می شود :
Application.Contents.RemoveAll()

متد Lock
اين متد مانع تغيير دادن متغيرهای شئ Application توسط كاربران می شود. همچنين مانع از دسترسی بيش از يك نفر در يك زمان به يك متغير Application می شود.

متد UnLock
اين متد، متد Lock را خنثی می كند و اجازه تغيير دادن متغيرهای Application را به بقيه كاربران می دهد.

visits")=Application("visits")+1
Application.Unlock
%>
This page has been visited
<%=Application("visits")%> times!

در مثال بالا از متد Lock برای جلوگيری از دسترسی بيش از يك كاربر به متغيرها استفاده شده است و متد UnLock كه در واقع پايان كار متد Lock است و در آخر كد آمده است به كاربر بعدی اجازه اضافه كردن يك واحد به متغير را می دهد.

رويداد Application_OnStart
قبل از اينكه اولين جلسه كاربری جديد تشكيل شود اين رويداد رخ می دهد (وقتی كه شئ Application اولين مراجعه را دارد ) توجه كنيد كه جای اين رويداد داخل فايل Global.asa است.
نكته: مراجعه به اشياء Request , Session و يا Response در اين رويداد باعث بروز خطا در اسكريپت می شود.

رويداد Application_OnEnd
اين رويداد هنگامی كه يك برنامه ASP بكار خود پايان می دهد و يا هنگامی كه سرور به حالت Stop می رود رخ می دهد. جای قرار دادن اين رويداد نيز داخل فايل Global.asa است.
نكته: متد MapPath از شئ Server نمی تواند در اين رويداد استفاده شود.

قاعده تركيبی دو رويداد فوق در فايل Global.asa :

vbscript" runat="server">
Sub Application_OnStart
. . .
End Sub
Sub Application_OnEnd
. . .
End Sub
</script>

برای مشاهده مثال دو رويداد فوق به مقاله ايجاد كنتور برای كاربران فعال در صفحه رجوع كنيد.

همه مقالات ASP کلاسيک را ببينيد.
جستجو: بگرد!
جستجوی پيشرفته
نام کاربری |
کلمه عبور |


IranASP.NET - ارتباط ASP با بانكهای اطلاعاتی

ارتباط ASP با بانكهای اطلاعاتی

حميد استادهاشمی | اين مقاله ۷۷۰۴ بار تاکنون ديده شده است.
۱۳۸۰/۱۱/۱۶ | برای وبلاگ برای وبلاگ
بررسی SQL و ADO و نحوه برقراری ارتباط بين آنها و ASP

ازآنجا كه برقراری ارتباط با بانكهای اطلاعاتی يكی از مباحث مهم و پركاربرد در ASP است، در اين مقاله سعی شده است با معرفی SQL و ADO، نحوه برقراری ارتباط ASP با بانكهای اطلاعاتی بطور خلاصه شرح داده شود.

SQL يك زبان استاندارد ANSI برای دستيابی به يك بانك اطلاعاتی و همچنين پرس و جو از بانك اطلاعاتی است. زبان SQL با برنامه های بانك اطلاعاتی مانند: Access, Oracle, MS SQL Server, DB2, Informix & ... كار می كند. چون SQL زبان استاندارد بانكهای اطلاعاتی است برای دستيابی به بانكهای اطلاعاتی از اين زبان استفاده می شود.

دستورات زير برای پرس و جو از بانكهای اطلاعاتی در SQL بكار می رود:

Select : داده ها را از بانك اطلاعاتی فراخوانی ميكند.
Insert : داده ها را به بانك اطلاعاتی اضافه می كنند .
Update : داده ها را در بانك اطلاعاتی تغيير می دهند و به روز می كنند.
Delete : داده ها را از داخل بانك اطلاعاتی پاك می كنند.

در ASP برای ارتباط با بانك های اطلاعاتی از ADO استفاده می شود و ADO برای پرس و جو از بانك اطلاعاتی از زبان استاندارد SQL استفاده می كند. يعنی برای ارتباط با بانكهای اطلاعاتی از داخل صفحات ASP بايد هم SQL و هم ADO را فرا بگيريد زيرا از هر دوی آنها به طور مشترك در ASP استفاده می شود.

ADO يك زبان نيست بلكه يك تكنولوژی است كه توسط ميكروسافت برای دسترسی به بانكهای اطلاعاتی از داخل صفحات وب ساخته شده است كه به همراه IIS در ويندوز نصب می شود. برای برقراری ارتباط با بانك های اطلاعاتی بوسيله ADO دو راه وجود دارد.

۱- ارتباط DSN_LESS
اين نحوه ارتباط به اين صورت است كه بعد از ساختن يك شئ Connection و مشخص كردن درايور بانك اطلاعاتی، مسير فايل بانك اطلاعاتی را مشخص می كنيم و بدين صورت بانك اطلاعاتی را از داخل صفحه وب معرفی می كنيم. در مثال زير، يك بانك اطلاعاتی را از درايو C باز كرده ايم:

ADODB.Connection")
conn.Provider="Microsoft.Jet.OLEDB.4.0"
conn.Open "c:/webdata/northwind.mdb"
%>

۲- ارتباط ODBC
نحوه برقراری ارتباط ODBC با يك بانك اطلاعاتی MS Access :
آيكون ODBC را از داخل پنجره ControlPanel انتخاب كنيد و روی قسمت DSN System كليك كنيد، دكمه ADD را برای ساختن يك ارتباط جديد كليك كنيد. سپس Microsoft Access Driver را انتخاب کزده و روی Finish كليك كنيد. در صفحه بعد روی دكمه Select كليك كنيد و مسير فايل بانك اطلاعاتی را مشخص نمائيد. سپس در فيلد Name نام بانك اطلاعاتی خود را وارد نماييد و OK را فشار دهيد.

تا اين مرحله شما يك ارتباط ODBC را برای يك بانك اطلاعاتی ساخته ايد حال برای فراخوانی اين بانك از داخل صفحه ASP كد زير را داخل صفحه ASP بنويسيد:

ADODB.Connection")
conn.Open "northwind"
%>

در روش اول برای برقراری ارتباط نياز به DSN System در ODBC نداريم و تمام اعمال مربوط به ارتباط در داخل صفحه ASP انجام می شود لذا اين روش هنگامی مفيد است كه ميزبان شما يك سرور خارجی باشد و يا اينكه شما به ميزبان سايت خود دسترسی فيزيكی نداشته باشيد. اما اگر به سرور ميزبان سايت خود دسترسی داريد می توانيد از روش دوم استفاده كنيد. البته در اين حالت از روش اول هم می توانيد استفاده كنيد. اما پيشنهاد می شود كه در هر حالت شما از روش اول يعنی DSN_LESS استفاده كنيد زيرا در تمام حالات و وضعيت ها جواب می دهد و مشكلی پيش نخواهد آمد.

همه مقالات ASP کلاسيک را ببينيد.
جستجو: بگرد!
جستجوی پيشرفته
نام کاربری |
کلمه عبور |


IranASP.NET - نشان دادن قابليتهای مرورگر در ASP.NET

نشان دادن قابليتهای مرورگر در ASP.NET

شاهو طوفانی | اين مقاله ۵۵۸۱ بار تاکنون ديده شده است.
۱۳۸۰/۱۱/۲۰ | برای وبلاگ برای وبلاگ دريافت کد
اين مقاله نحوه نشان دادن قابليتهای مرورگر با استفاده از ASP.NET را نشان می دهد.

اگرچه در حال حاضر جنگ مرورگرها تقريبا تمام شده است اما اين موضوع دليلی بر شناخته نشدن قابليتهای مرورگرها نيست. در اينجا توانايی ASP.NET در نشان دادن قابليتهای مرورگرها بحث شده است. بعنوان نمونه، مثال ۱ نوع مرورگر را به ما نشان می دهد.

<html><body>
You are using <% =Request.Browser.Type %>
</body></html>

برای نمونه اگر شما از IE 5 استفاده می کنيد نتيجه خروجی چنين بايد باشد:

You are using IE5

در مثال ۱ Request.Browser.Type يک رشته را که همان نام ونسخه‎ی مرورگر است را بر می گرداند. اما اين موضوع چگونه صورت ميگيرد ؟

شئ HTTPBrowserCapabilities
در حقيقت خاصيت Browser در شئ Request کلاسی از HTTPBrowserCapabilities است که در فضانام System.Web قراردارد. وقتی که اين کلاس روی يک صفحه ASP.NET نمونه سازی می شود خواص صفحه سرويس گيرنده ای را نشان می دهد که از آن برای اجرا شدن کد استفاده شده است. شئ Request در برگيرنده اين خاصيت مرورگر است که اين کلاس را ميتوان معادل کلاس MSWC. BrowserCapabilities در ASP کلاسيک در نظر گرفت.

در ليست زير اکثر خاصيتهای شی HTTPBrowserCapabilities تشريح شده است:

ActiveXControls: نشان می دهد که مرورگر اکتيويکس را ساپورت می کند يا نه.
AOL: چک می کند که مرورگر از نوع AOL است يا نه.
Cookies: نشان می دهد که مرورگر کوکی ها را ساپورت می کند يا نه بايد توجه داشت که اين خاصيت وضعيت فعال بودن يا غير فعال بودن کوکی ها را نشان نمی دهد.
Crawler: نشان ميدهد که مرورگر سرويس گيرنده از موتورهای جستجو تاثير می پذيرد يا نه.
Browser: نوع مرورگر را نشان می دهد.
Frames: نشان می دهد که مرورگر از قابليت Frame برخورداراست يا نه.
MajorVersion: نسخه اصلی مرورگر را نشان می دهد بعنوان مثال در IE5 عدد 5 نشانگر نسخه اصلی است.
MinorVersion: نسخه جزيی (کوچکتر) مرورگر را نشان می دهد بعنوان مثال در IE5.1 عدد .1 نشانگر نسخه جزيی است.
Type: نوع ونسخه مرورگر را بصورت يک رشته بازميگرداند..
VBScript: نشان می دهد که مرورگر VBScript را ساپورت می کند يا نه.
Version: نسخه اصلی و جزيی مرورگر را بعنوان يک رشته برمی گرداند.

در زير نمونه کامل يک مثال آورده شده است.

<%@ page language="VB" %>
<%@ Import Namespace="System.Web" %>
<html>
<body>
<head><title>HTTPBrowserCapabilities Demo</title></head>

<%
Dim browserObj As HTTPBrowserCapabilities
browserObj = Request.Browser
%>
<font face="verdana, arial" size=2>

<p>Your browser supports ActiveX controls: <%=browserObj.ActiveXControls %> </p>
<p>Your browser type: <%=browserObj.Type %> </p>
<p>Your browser version: <%=browserObj.Version%> </p>

... Add any other property that you would like to display

</font>
</body>
</html>

همه مقالات کليات ASP.NET را ببينيد.
جستجو: بگرد!
جستجوی پيشرفته
نام کاربری |
کلمه عبور |


IranASP.NET - مقدمه ای بر XML

مقدمه ای بر XML

مسلم ابراهيمی | اين مقاله ۶۶۷۶ بار تاکنون ديده شده است.
۱۳۸۰/۱۱/۲۷ | برای وبلاگ برای وبلاگ دريافت کد
دنيای XML چگونه است و چگونه بايد شروع كنيم، درآينده XML يكی از محورهای دات نت است.

• XML برای شرح و بيان اطلاعات طراحی شده است.
• HTML برای نمايش اطلاعات و برای تمركز روی چگونگی ديده شدن اطلاعات طراحی شده است.

قبل از ادامه اين بحث، شما بايد مقداری درك پايه ای از موارد زير داشته باشيد:
• WWW,HTML و اساس ساخت صفحات وب
• زبانهای اسكريپت وب مانند JavaScript , VBScript

XMLچيست؟
• XML برگرفته شده از كلمات Extensible Markup Language است.
• XML يك Markup Language مانند HTML است.
• tag (برچسب) های XML از قبل تعريف شده نيستند، شما خودتان بايد آنها را تعريف كنيد.
• XML از يك (Document Type Definition) DTD برای شرح اطلاعات استفاده ميكند.
• XML با يك DTD طراحی ميشود تا خود-توصيف باشد.

تفاون اصلی بين XML و HTML
• XML برای حمل اطلاعات طراحی شده است.
• XML يك جايگزين برای HTML نيست.
• XML و HTML برای هدفهای مختلفی طراحی شده اند.
• HTML برای نمايش اطلاعات و XML برای شرح و حمل و نقل اطلاعات است.

XML كاری انجام نميدهد!
شايد اين موضوع برای درك كردن كمی مشكل باشد، اما XML كاری انجام نميدهد. XML ساخته نشده تا كاری انجام دهد. XML به عنوان يك راه برای سازماندهی كردن، ذخيره كردن و فرستادن اطلاعات ساخته شده است. مثال زير يك يادداشت از Jani به Tove است كه در ساختار XML ذخيره شده است:

<note>
<to>Tove</to>
<from>Jani</from>
<heading>Reminder</heading>
<body>Dont forget me this weekend!</body>
</note>

يادداشت يك سرباره (header) و يك بدنه اصلی پيغام دارد، همچنين اطلاعات فرستنده و گيرنده را هم در بر دارد. اما هنوز اين سند XML كاری انجام نميدهد. آن فقط اطلاعات محضی است كه در برچسبهای XML قرار گرفته است.

XML آزاد و قابل گسترش
• برچسبهای XML از قبل تعريف شده نيستند، شما بايد برچسبها را خودتان درست كنيد.
• برچسبهايی كه در HTML بكار ميروند از پيش تعريف شده هستند و مؤلف سندهای HTML فقط ميتواند از برچسبهای تعريف شده در HTML استاندارد استفاده كند ( مانند <p> و<h1>).
• XML به مؤلف اجازه ميدهد تا برچسبهای خود و ساختار آنها را تعريف كند.
• برچسبهای مثال بالا ( مانند <to>و<from>) در XML استاندارد تعريف شده نيستند، اين برچسبها توسط مؤلف سند XML تعريف شده اند.

XML يك مكمل برای HTML
• XML يك جايگزين برای HTML نيست.
• درك اينكه XML يك جايگزين برای HTML نيست خيلی مهم است.
• در آينده گسترش وب احتمال داده ميشود كه XML برای شرح اطلاعات به كار خواهد رفت،درحاليکه كه HTML برای فرمت و نمايش اطلاعات به كار خواهد رفت.
• شايد اين بهترين تعريف از XML باشد: ابزاری مستقل از سخت افزار و نرم افزار برای انتقال اطلاعات است.

XML ميتواند اطلاعات را از HTML جدا كند
• با XML اطلاعات شما در خارج از HTML ذخيره ميشود.
• هنگامی كه HTML برای نمايش اطلاعات استفاده ميشود، اطلاعات در درون HTML ذخيره شده است. با XML اطلاعات ميتواند در فايلهای جدای XML ذخيره شود. در اين روش شما ميتوانيد HTML را به عنوان لايه ای روی اطلاعات و برای نمايش آنها فرض كنيد و مطمئن باشيد كه تغيير در اطلاعات لايه های زيرين احتياج به تغيير HTML شما نخواهد داشت.

همه مقالات سرويس های XML وب را ببينيد.
جستجو: بگرد!
جستجوی پيشرفته
نام کاربری |
کلمه عبور |


IranASP.NET - زبان فارسی در HTML

زبان فارسی در HTML

مديريت سايت | اين مقاله ۱۰۱۳۵ بار تاکنون ديده شده است.
۱۳۸۰/۱۱/۲۷ | برای وبلاگ برای وبلاگ دريافت کد
چگونگی ساخت صفحات HTML بصورت فارسی با تعيين مجموعه نويسه و زبان مورد استفاده

کنسرسيوم وب (W3C) استانداردهای HTML و CSS را با يک ديد کلی به همه زبانها و مليتها در نظر گرفته است. بخصوص راجع به زبانهای موجود در خاورميانه که از راست به چپ هستند. زبان فارسی و عربی از جمله اين زبانها می باشند. لازم بذکر است که زبان فارسی و چند زبان ديگر مانند اردو و پشتو بعنوان بخشی از زبان عربی در نظر گرفته شده اند. اما اين مساله نه تنها سبب عدم بکارگيری فارسی در دنيای اينترنت نيست بلکه دريچه ارزشمندی است که بسوی زبان فارسی گشوده شده است تا بلکه در آينده نگاه مستقلی به اين زبان ايجاد گردد. زبان فارسی در استاندارد يونيکد تحت بلوک زبان عربی اين استاندارد بخوبی پشتيبانی شده است و امروزه تنها راه بکارگيری زبان فارسی در اينترنت بصورت استاندارد محسوب می شود.

مجموعه مقالاتی که در اين زمينه ارائه می گردد با الهام از مقاله ای بنام Authoring HTML for Middle Eastern Content منتشره توسط شرکت مايکروسافت در سال 2001 می باشد. در اين مقالات سعی خواهد شد روش های ساخت صفحات وب بصورت فارسی با استفاده از HTML 4.0 و CSS2 بيان گردد.

مجموعه نويسه
جهت نمايش صحيح يک صفحه وب، مرورگر بايد نوع مجموعه نويسه ای که در آن صفحه استفاده شده است را بداند. جهت اين امر بايد نوع مجموعه نويسه در قسمت HEAD صفحه HTML قبلا معرفی شده باشد. برای اينکار از يک تگ META بين تگ های <HEAD> و <HEAD/> بصورت زير استفاده می کنيم:

<META HTTP-EQUIV="Content-Type" CONTENT="text/html; charset=utf-8">

در حالت فوق مجموعه نويسه صفحه بصورت utf-8 مناسب برای صفحات فارسی بصورت يونيکد تعريف شده است. برای صفحات وب با زبانهای خاورميانه ای معمولا مجموعه نويسه های زير را داريم:

iso-8859-1 - ISO Latin-1 standard (no Arabic characters included)
iso-8859-6 - ISO Arabic standard
windows-1252 - Windows 1252 (no Arabic characters included)
windows-1256 - Windows Arabic codepage
asmo-708 - ASMO 708 codepage
dos-720 - Arabic DOS 720 codepage

بخاطر داشته باشيد که مجموعه نويسه ها محدود هستند. اگر نويسه ای در يک صفحه استفاده شده است که در مجموعه نويسه تعيين شده برای صفحه وجود ندارد، اين مساله بايد بصورت صريح برای مرورگرمشخص گردد تا عمل نمايش صفحه بدرستی انجام پذيرد.

تعيين زبان
با استفاده از مشخصه LANG می توان نوع زبان را برای هر يک از عناصر HTML مانند بدنه، پاراگراف، متن و غيره را مشخص نمود. تعيين اين مشخصه می تواند در موارد زير مفيد باشد:

• تشخيص زبان برای موتورهای جستجو
• کمک به مرورگر جهت انتخاب نوع بهتر نمايش شکل نويسه ها
• کمک به مرورگر جهت رعايت علائم و نقطه گذاری، فواصل، اتصال يا جداسازی حروف
• کمک به برنامه های غلط گير املائی يا انشائي

بعنوان مثال می توان زبان را برای تگ‎های <P> و <BODY> بصورت زير تعريف نمود:

<BODY LANG="fa">
<P LANG="fa">

همچنين می توان اين عمل را يک بار برای کل صفحه در قسمت HEAD بصورت زير تعريف نمود:

<META HTTP-EQUIV="Content-Language" CONTENT="fa">

در عبارت فوق که در قسمت HEAD صفحه HTML می آيد با استفاده از علامت fa نوع زبان، فارسی تعريف شده است. توجه داشته باشيد که تقدم مشخصه LANG برای هر عنصر HTML از عبارت فوق بالاتر است.

هر زبان علامت يا مجموعه علائم مخصوص به خود را دارد که همه اين علائم مشخص شده اند و می توانيد استاندارد مربوطه را در [RFC1766] ببينيد. بعنوان مثال برای زبان انگليسی از en و برای عربی از ar استفاده می شود.

اندازه فونت
هنگامی که مرورگر، يک صفحه با متون مختلف، مثلا فارسی و انگليسی را نمايش می دهد ممکن است استفاده از اندازه فونت پيش فرض برای هر دو زبان، سبب نمايش نادرست و يا ناموزون صفحه گردد. بعبارت ديگر مثلا ممکن است متون فارسی در مقابل متون انگليسی خيلی کوچکتر به نظر برسند.

بهترين راه حل برای حل چنين مشکلی تعيين اندازه فونت برای هر نوع از متون است. بدين منظور برای راحتی کار می توان از CSS استفاده نمود. در مثال زير دو نوع مدل يکی برای نمايش متون فارسی و ديگری برای نمايش متون انگليسی تعريف و استفاده شده است.

<STYLE type="text/css">
SPAN.farsi
{ font-face: Times New Roman;
font-size: 12pt; }
SPAN.english
{ font-face: Times New Roman;
font-size: 10pt; }
</STYLE>
<BODY>
<P>
<SPAN class="farsi">.سلام اينجا ايران است</SPAN>
<SPAN class="english">Hello, This is Iran.</SPAN>
</P>
</BODY>

همه مقالات فارسی در وب را ببينيد.
جستجو: بگرد!
جستجوی پيشرفته
نام کاربری |
کلمه عبور |


IranASP.NET - آشنايی با فايل Global.asa

آشنايی با فايل Global.asa

محمد جواد سخائی | اين مقاله ۵۴۹۶ بار تاکنون ديده شده است.
۱۳۸۰/۱۲/۱ | برای وبلاگ برای وبلاگ دريافت کد
نحوه بکارگيری فايل Global.asa و کاربردهای آن در يک برنامه ASP کلاسيک

در فايل Global.asa، می توان اسكريپت هائی را تعريف نمود كه همزمان با بروز يك رويداد ( Event ) فعال شده و يا اقدام به تعريف اشياء Session و Application نمود. امكانات تعريف شده در فايل فوق برای تمامی صفحات تشكيل دهنده يك برنامه ASP قابل دستيابی و استفاده خواهند بود. ضرورت وجود فايل فوق اختياری بوده و در صورت تعريف می بايست در فهرست ريشه ای كه برنامه ASP در آن قرار دارد، استقرار يابد. هر برنامه ASP صرفا می تواند دارای يك فايل Global.asa باشد.

رويدادهای استاندارد در فايل Global.asa
در فايل فوق می توان به اشياء Application و Session گفت كه در زمان آغاز و خاتمه عمليات مربوط به خود چه كارهائی را انجام دهند. در مجموع در فايل فوق چهار نوع رويداد را می توان قرار داد :

• Application_OnStart: رويداد فوق زمانيكه اولين كاربر به اولين صفحه يك برنامه ASP دستيابی پيدا می كند، فعال می گردد.
• Session_OnStart: رويداد فوق هر دفعه كه يك كاربر جديد درخواست اولين صفحه يك برنامه ASP را داشته باشد، فعال می گردد.
• Session_OnEnd: رويداد فوق هر بار كه كاربری به جلسه كاری خود خاتمه می دهد فعال می گردد. در صورتيكه در يك مدت زمان مشخص و محدود ( پيش فرض بيست دقيقه ) در خواست صفحه ای توسط كاربر واصل نگردد، به جلسه كاری وی خاتمه داد می شود.
• Application_OnEnd: رويداد فوق پس از اينكه آخرين كاربر به كار خود خاتمه می دهد، فعال می گردد. معمولا رويداد فوق زمانيكه سرويس دهنده وب متوقف می گردد نيز فعال می گردد.

برای هر يك از رويدادهای فوق می توان روال هائی را نوشت كه مسئول برخورد با رويداد مربوطه باشند. اين روال ها درفايل Global.asa قرار می گيرند. چهارچوب كلی فايل فوق كه متضمن خواسته های چهارگانه فوق باشد می تواند بصورت زير باشد:

<script language="vbscript" runat="server">
sub Application_OnStart
. . .
end sub
sub Application_OnEnd
. . .
end sub
sub Session_OnStart
. . .
end sub
sub Session_OnEnd
. . .
end sub
</script>

با مشاهده چهارچوب فوق دوستان متوجه شده اند كه از <% و %> استفاده نشده و بمنظور استفاده از اسكريپت ها در فايل Global.asa می بايست از تگ <script> استفاده و روال های مربوطه را تعريف نمود.

در رابطه با فايل Global.asa محدوديت هائی وجود دارد كه ذيلا به آنها اشاره می شود:

• فايل فوق قادر به نمايش اطلاعات نمی باشد، بنابراين نمی توانيم بكمك آن متنی را نمايش دهيم.
• از دايركتيو Include# نمی توان در فايل فوق استفاده نمود.
• در روال های Application_OnStart و Application_OnEnd صرفا می توان از اشياء Server و Application استفاده كرد.
• در روال Session_OnEnd می توان از اشياء Server و Application و Session استفاده نمود.
• در روال Session_OnStart می توان از تمامی اشياء از پيش ساخته شده همراه ASP استفاده نمود.

نحوه استفاده از روال ها
از روال های موجود در يك فايل Global.asa می توان در جهت مقاصد مختلفی استفاده بعمل آورد. در ادامه به تشريح برخی از اين نوع اهداف خواهيم پرداخت.

• از فايل Global.asa اغلب برای مقداردهی اوليه متغيرها استفاده می شود. در مثال زير نحوه تشخيص زمان مربوط به ملاقات يك وب سايت توسط يك كاربر نشان داده شده است. زمان فوق در متغير started مربوط به شی Session ذخيره می گردد. مقدار متغير فوق توسط هر يك از صفحات موجود در يك برنامه ASP قابل دستيابی خواهد بود.

vbscript" runat="server">
sub Session_OnStart
Session("started")=now()
end sub
</script>

• از فايل Global.asa بمنظور كنترل دستيابی به صفحات نيز می توان استفاده كرد. در مثال زير پس از ارتباط كاربر با سايت، بصورت اتوماتيك وی بسمت استفاده از يك فايل ( MyNewPage.asp ) ديگر هدايت می گردد.

vbscript" runat="server">
sub Session_OnStart
Response.Redirect("MyNewPage.ASP")
end sub
</script>

در ادامه به بررسی يك مثال كاربردی از تاثير فايل فوق و نحوه استفاده از پتانسيل های ايجاد شده توسط فايل های ASP، خواهيم پرداخت.

مثال در اين مثال با استفاده از فايل Global.asa، تعداد ملاقات كنندگان فعال يك سايت را مشخص می نمائيم. در فايل فوق از سه روال استفاده خواهد شد كه هر يك عمليات محوله را انجام خواهند داد. روال Application_OnStart، متغير visitors مربوط به شی Application را صفر قرار می دهد. مقدار اوليه متغير فوق پس از اينكه سرويس دهنده كار را آغاز كرد، به آن داده خواهد شد. روال Application_OnStart زمانيكه يك ملاقات كننده جديد وارد سايت می گردد، يك واحد به متغير visitors اضافه كرده و در نهايت روال Session_OnEnd زمانيكه يك ملاقات كننده سايت را ترك می كند، يك واحد از متغير visitors كم می كند.

محتويات فايل Global.asa:

<script language="vbscript" runat="server">
Sub Application_OnStart
Application("visitors")=0
End Sub

Sub Session_OnStart
Application.Lock
Application("visitors")=Application("visitors")+1
Application.UnLock
End Sub

Sub Session_OnEnd
Application.Lock
Application("visitors")=Application("visitors")-1
Application.UnLock
End Sub
</script>

بمنظور نمايش تعداد ملاقات كنندگان فعال، می توان از يك فايل ASP مطابق زير استفاده نمود.

<html>
<head></head>
<body>
<p>You are one of the <%=Application("visitors")%> online user!</p>
</body>
</html>

پس از اجرای ASP فوق، خروجی زير را خواهيم داشت.

You are one of the 12 online user

همه مقالات ASP کلاسيک را ببينيد.
جستجو: بگرد!
جستجوی پيشرفته
نام کاربری |
کلمه عبور |


IranASP.NET - ويژگيهای دات نت

ويژگيهای دات نت

حامد بنايی | اين مقاله ۵۴۸۴ بار تاکنون ديده شده است.
۱۳۸۰/۱۲/۲ | برای وبلاگ برای وبلاگ
آشنائی با مايکروسافت دات نت و شناخت قابليتها و بررسی ويژگيهای آن

با اينکه مايکروسافت می دانست با ابزارهای قبلی شرکت می توان برنامه های اينترنتی نوشت ولی برای قبضه کردن بازار احتياج به تکنولوژی جديدی داشت . مايکروسافت از سال 1998 که ويژوال استوديو 6 را به بازار وارد کرد در پی حل اين مشکلات بود تا در سال 2000 NET. را در کنفرانس برنامه نويسان حرفه ای PDC به جهان معرفی کرد . از آن روز تا به حال مايکروسافت حدود 80 % از توانش را برای تکميل NET. مصرف کرده است . در همين راه پروتکلهای جديدی مانند SOAP يا Simple Object Access Protocol را ايجاد کرد . همچنين نسل جديدی از برنامه نويسی به عنوان Web Service را تهيه کرده است.

مهم ترين اهداف NET.

طراحی برنامه های اينترنتی بر سبک برنامه های Win32 GUI: همانطور که اشاره شد برنامه نويسی برای Win32 GUI از قدرت خوبی برخوردار است ، در NET. برنامه های اينترنتی نيز از همين قدرت برخوردارند .

داشتن رابط گرافيکی خوب اينترنتي: به علت تغييرات اساسی که در برنامه در اين سيستم داده شده برنامه اينترنتی قابليت گرافيکی در حد برنامه های Win32 GUI دارند .

انتقال ساده به سيستم های ديگر: در NET. براحتی می توان برنامه ها را با يک کپی ساده به کامپيوتر های ديگر انتقال داد .

پشتيبانی از زبانهای مختلف: در NET. به زبانهای برنامه نويسی مايکروسافت مثل ويژوال بيسيک ، سی شارپ و يا ++C محدود نيستيم . به طوری که در حال حاضر نسخه های Cobol.NET و Pascal.NET در حال ساخته شدن است . اما شرکت مايکروسافت زبان ويژوال بيسيک را به عنوان زبان اصلی برگزيده است . اين مساله ريشه در تاريخ مايکروسافت دارد !

Platform های آينده: هم اکنون NET. برای ويندوز نوشته شده است ولی در آينده نزديک نسخه های Unix و Linux و همچنين برای Mobile و PDA نيز ارائه خواهد شد . اين امر اين امکان را می دهد که برنامه ای که برای ويندوز در NET. نوشته ايد در تمامی سيستم عامل ها و دستگاه های بالا قابل اجرا باشد. در ادامه توضيحات کامل برای اين مبحث ارائه خواهد شد .

ساختار NET.
مهمترين ويژگی در NET. Framework اين است که تمام لايه های برنامه نويسی را در بالای سيستم عامل دربرمی گيرد . که اين شامل تمامی تکنولوژی های موجود که از طرف مايکروسافت يا شرکتهای ديگر ارائه شده است، می شود . در NET. تمام اعمال تخصيص حافظه و سازماندهی فايل برعهده NET Framework. است و همين اصل باعث می شود که بتوان برنامه هايی نوشت که به سيستم عامل متکی نباشد. در اين آدرس می توانيد تصوير ساختار NET. را مشاهده کنيد.

CLR زير ساختار NET.
قلب NET Framework. همان CLR يا Common Language Runtime می باشد . CLR مسئول اجرای فايل ها ، فراخوانی آنها به حافظه و کامپايل کردن آنها به زبان MSIL يا Microsoft Intermediate Language است . بعدا ً کدهای IL در هنگام اجرا، بوسيله برنامه کامپايلر just-in-time به زبان ماشين تبديل می شود . اين بدين معناست که در NET. دو مرحله برای کامپايل شدن وجود دارد . اولين مرحله وقتی است که برنامه به هر زبان NET. که باشد به IL کامپايل می شود که اين کد کامپايل شده به IL قابليت پخش در تمام NET Framework. را دارد و بستگی به سيستم عامل ندارد . مرحله دوم زمان اجرا است که کامپايلر just-in-time کد IL را به زبان آن ماشينی که برنامه در آن می خواهد اجرا شود کامپايل می کند. CLR عهده دار برنامه نويسی شی گرا در سطح زبان های NET. است ، برای مثال شما می توانيد يک object در سی شارپ داشته باشيد و آن را در ويژوال بيسيک فرا بخوانيد و همچنين بوسيله وراثت تغييراتی در آن object بدهيد . همچنين CLR بر Garbage Collection ها نيز نظارت می کند . بحث کامل درباره CLR در ادامه خواهد آمد .

کلاس های پايه در NET Framework.
اين لايه حاوی تمامی کلاس ها و آبجکت هايی است که معمولا ً مورد نياز برنامه نويسان می باشد ، از جمله ADO.NET که نسل جديد ADO است ، XML که قسمت زيادی از NET. از اين تکنولوژی استفاده می کند ، Threading يا آبجکت هايی برای برنامه نويسی ِ هر thread .

ASP.NET و Windows Forms
در مرحله بعدی دو روش کلی برنامه نويسی تحت اينترنت و تحت client قرار دارد که هر کدام خواص و آبجکت های مخصوص آن روش برنامه نويسی را دارا هستند .

خلاصه از کتاب Professional VBNET. از Wrox

همه مقالات کليات ASP.NET را ببينيد.
جستجو: بگرد!
جستجوی پيشرفته
نام کاربری |
کلمه عبور |


IranASP.NET - کنترل HyperLink يا پيوند

کنترل HyperLink يا پيوند

شاهو طوفانی | اين مقاله ۴۳۰۴ بار تاکنون ديده شده است.
۱۳۸۰/۱۲/۵ | برای وبلاگ برای وبلاگ دريافت کد
نشان دادن پيوند با استفاده از HyperLink وخصوصيات آن

جهت نشان دادن پيوند (لينک) در يک صفحه ASP.NET ميتوان از کنترل HyperLink استفاده کرد. برای اين منظور عبارت پيوند را ميتوان در خاصيت Text پيوند نشان داد و بوسيله خاصيت NavigateUrl آدرس پيوند را مشخص کرد همچنين بوسيله خاصيت ImageUrl از کنترل عبارت پيوند را با تصويری جايگزين کرد که هنگام کليک روی تصوير ما به صفحه ای که در خاصيت NavigateUrl مشخص شده است هدايت خواهيم شد. مثال زير نحوه عملکرد اين کنترل را نشان می دهد:
(بايد توجه داشت در اين مثال شما به تصويری با عنوان hyper.gif در پوشه برنامه نيازداريد.)

<%@ Page Language="VB" Debug="True" %>
<html>
<head>
<title>HyperLink Control</title>
</head><body>
<asp:HyperLink id="hl1" runat="server"
NavigateUrl="http://www.iranasp.net"
Text=" Go to IranASP.NET" />
<br>
<asp:HyperLink id="hl2" runat="server"
NavigateUrl="http://www.iranasp.net/forum"
ImageUrl="hyper.gif"
Text="Go to IranASP.NET Forum"/>
<br>
<br>
</body>
</html>

همه مقالات فرم های وب را ببينيد.
جستجو: بگرد!
جستجوی پيشرفته
نام کاربری |
کلمه عبور |


IranASP.NET - الحاق يک ListBox به شئ ArrayList

الحاق يک ListBox به شئ ArrayList

شاهو طوفانی | اين مقاله ۵۰۹۹ بار تاکنون ديده شده است.
۱۳۸۰/۱۲/۵ | برای وبلاگ برای وبلاگ دريافت کد
اين مقاله نحوه تركيب و فراخوانی داده ها را از طريق شئ ArrayList نشان می دهد.

در ASP.NET معمولا محتويات يک ListBox از درون کد رويداد Page_Load استخراج می گردد. در ASP.NET می توان داده های يک کنترل را از يک منبع داده ( Data souce ) تامين کرد. در اين حالت کنترل بصورت خودکار مقادير موجود در منبع داده را به خود می گيرد. برای اين منظور می توان از يکی از اشياء رايج و پرکاربرد در ASP.NET که همان ArrayList است بهره برد.

اغلب برای ساختن و فراخوانی مجموعه ای از اشياء از ساختاری مشخص تبعيت می شود که اين ساختار با عنوان مجموعه اشياء (Objects (Collection شناخته می شود. بعنوان مثال ArrayList يک مجموعه اشياء است. در مجموع، الحاق يک کنترل ListBox به يک Datasource ساده است. برای اينکار کافيست که خاصيت Datasource يک کنترل معلوم شود. سپس با استفاده از متد DataBind مربوط به آن کنترل، ارتباط آن با ListBox مشخص می شود. در مثال زير ابتدا يک ArrayList از نام گلها ساخته می شود و سپس کنترل ListBox (در اينجا lstFlowers) برای فراخوانی داده به ArrayList متصل می شود. مثال زير چگونگی انجام کار را نشان ميدهد.

<% @Page Language="VB" Debug="True" %>
<html><head><title>Databing Demo</title></head>
<body>
<form runat="server">
Select a flower, and then click the submit button please:
<br>
<asp:ListBox id="lstFlowers" runat="server" rows="3"
AutoPostBack="True" onSelectedChanged="showSelection"/>
</asp:ListBox>
<br><br>
<asp:Label id=lblMessage runat="server"></asp:Label></p>
</form>
</body></html>
<script language=vb runat="server">
sub Page_Load(source As Object, e As EventArgs)
if Not Page.IsPostBack Then
Dim myArrayList As New ArrayList
myArrayList.Add("Azalea")
myArrayList.Add("Tulip")
myArrayList.Add("Rose")
lstFlowers.DataSource=myArrayList
lstFlowers.DataBind()
lstFlowers.SelectedIndex=0
end if
end sub
sub showSelecttin(Sender As Object, e As EventArgs)
lblMessage.Text="You have selected " +lstFlowers.SelectedItem.Text
end sub
</script>

همه مقالات فرم های وب را ببينيد.
جستجو: بگرد!
جستجوی پيشرفته
نام کاربری |
کلمه عبور |


IranASP.NET - مروری بر ساختار برنامه های NET.

مروری بر ساختار برنامه های NET.

حامد بنايی | اين مقاله ۵۳۶۲ بار تاکنون ديده شده است.
۱۳۸۰/۱۲/۶ | برای وبلاگ برای وبلاگ
هر برنامه ای که بر مبنای دات نت تعريف می شود از سه قسمت مهم و اصلی تشکيل شده است: اسمبلی، ماژول و تايپ.

هر برنامه ای که بر مبنای NET. تعريف می شود از سه قسمت مهم و اصلی تشکيل شده است: Assemblies ، Modules و Types . اسمبلی ها اصلی ترين جز برای انتقال برنامه های NET. هستند (Deployment). ماژول ها فايلهايی هستند که اسمبلی از روی آنها ساخته می شود و تايپ ها، واحد های پايه برای تعريف داده ها، property ها و توابع هستند.

اسمبلی ها
اسمبلی تشکيل شده از manifest و يک يا چند فايل ماژول، XML يا HTML.

Manifest نيز دارای اجزای زير است:

• اطلاعاتی درباره خود اسمبلی که به صورت text ذخيره شده است. نمونه اين اطلاعات، نام، ورژن، عمومی يا غير عمومی بودن اسمبلی و ... است.
• نوع حفاظتی اسمبلی را توضيح می دهد. هر اسمبلی می تواند برای اجرا شدن نوع خاصی از لايه امنيتی داشته باشد که بر سه نوع است: Required ،Optional و Denied.
• اطلاعاتی درباره اسمبلی های ديگر که يک اسمبلی به آنها وابسته است از قبيل نام و نسخه آنها.
• اطلاعاتی از قبيل زبان محلی اسمبلی، تاريخ، واحد پول و غيره.

ماژول ها
ماژول ها يا فايلهای DLL هستند يا فايلهای EXE Windows PE (Portable Executable) که حاوی IL ، Meta Data و به صورت اختياری دارای manifest می باشد. هر اسمبلی فقط يک manifest می تواند داشته باشد، بنابراين اگر ماژولی حاوی manifest نيز بود فقط همان ماژول است که manifest دارد. CLR دو روش برای کامپايل هر فايل IL دارد، يکی install-time است که در زمان نصب برنامه فعال می شود و ديگری JIT يا کامپايلر just-in-time که به صورت method by method برنامه را کامپايل می کند. يعنی هنگامی که برنامه هر متد را صدا می زند کامپايل هم می شود . به صورت عادی برنامه ها به روش JIT کامپايل می شوند. Meta Data حاوی اطلاعات بيشتری درباره تعريف تايپ ها می باشد و به صورت IL است.

تايپ ها
تايپ ها دو نوع هستند، Value و Reference . هر تايپ دارای property ، method و field است. در ادامه درباره تايپ ها توضيحات بيشتری داده خواهد شد.

خلاصه از کتاب Professional VB.NET از Wrox

همه مقالات کليات ASP.NET را ببينيد.
جستجو: بگرد!
جستجوی پيشرفته
نام کاربری |
کلمه عبور |


IranASP.NET - طرح بندی صفحات فارسی

طرح بندی صفحات فارسی

مديريت سايت | اين مقاله ۶۷۴۲ بار تاکنون ديده شده است.
۱۳۸۰/۱۲/۱۱ | برای وبلاگ برای وبلاگ
مهمترين مبحث در طرح بندی و ساخت صفحات فارسی در HTML با استفاده از بکارگيری DIR در تعيين جهت متن

با استفاده از مشخصه DIR که از کلمه direction مشتق شده است می توان در HTML جهت يا طرح بندی (layout) تگ های HTML را مشخص نمود. بعبارت ديگر مثلا می توان جهت متن را بصورت راست به چپ تعيين نمود. کاربرد اين مساله برای زبانهائی است که جهت نوشتار آنها از راست به چپ می باشند مانند زبان فارسي. مساله تعيين جهت در صفحات HTML فارسی از موارد کليدی و اساسی بحث فارسی وب است.

استاندارد يونيکد جهت نوشتاری زبان ها را پيش بينی کرده است و برای اين منظور نويسه های کنترلی خاصی را در نظر گرفته است که براساس يک الگوريتم مشخص طرح بندی مناسب زبان مورد استفاده را مشخص می کنند. اين الگوريتم بنام "الگوريتم دو سويه يونيکد" يا Unicode Bidirectional Algorithm شناخته می شود. برخی از اين نويسه های مخصوص عبارتند از LRM ،RLM ،RLO و LRO .

در ساخت صفحات HTML دو جهته يا بطورکلی صفحاتی که نياز به تعيين جهت دارند مانند صفحات فارسی بهتر است که از مشخصه DIR برای عناصر HTML بجای نويسه های خاص يونيکد استفاده کرد. زيرا نويسه های کنترلی يونيکد در طرح بندی متون در اغلب ويرايشگرهای متنی قابل مشاهده نيستند و اين مساله ممکن است سبب سردرگمی نويسنده گردد.

مشخصه DIR می تواند توسط تگهای داخلی به ارث برده شده يا تغيير داده شوند. بعبارت ديگر اگر برای تگ <BODY> در يک صفحه HTML مشخصه DIR مقداردهی شود، اين مقدار برای تگ <P> که درون <BODY> قرار دارد نيز معتبر است يا بعبارت ديگر به ارث برده می شود. همچنين تگ <P> می تواند مشخصه DIR مختص خود را داشته باشد و بصورت ديگری آن را مقداردهی کند.

استفاده از DIR در <HTML> يا <BODY>؟
براساس تعريف زبان HTML، استفاده از DIR در تگ <HTML> در کل طرح بندی صفحه اثر می گذارد. اين اثرات بشرح زير است:

• خاصيت Ambient مربوط به شئ های OLE/COM در صفحه به مقدار AMBIENT_RIGHTTOLEFT مقداردهی می گردد.
• از طريق DOM يا Document Object Model می توان جهت صفحه را با استفاده از اسکريپتهای نزد کاربر تغيير داد.
• پنجره های مشتق شده از پنجره اصلی اين خاصيت را به ارث می برند.
• در صورت وجود scrollbar عمودی در پنجره، اين scrollbarها در سمت چپ صفحه نمايش قرار می گيرند.

استفاده از DIR=RTL در تگ <BODY> موارد زير را بهمراه دارد:

• خاصيت Ambient مربوط به اشياء OLE/COM فعال نخواهد شد.
• امکان تغيير جهت صفحه از طريق DOM ميسر نخواهد بود.
• پنجره های مشتق شده و عنوان پنجره تحت تاثير اين مساله قرار نخواهند گرفت.
• محل scrollbar براساس جهت <BODY> مشخص خواهد شد و نه جهت <HTML>

ترازبندی (Alignment)
مشخصه DIR در مورد برخی تگ ها بطور خودکار عمل ترازبندی را هم انجام می دهد. بعبارت ديگر هرگاه مشخصه DIR=RTL برای تگهای <P> و <H1> استفاده شود، ترازبندی اين تگها بصورت پيش فرض از راست خواهد بود و ديگر نيازی به ALIGN=RIGHT نيست.

جدول
قراردادن مشخصه DIR در تگ <TABLE> بصورت <TABLE DIR=RTL> سبب می شود تا کل طرح بندی جدول از راست به چپ شود. يعنی در حالت عادی (چپ به راست) اگر ستونی در منتها اليه سمت چپ جدول باشد (اولين ستون) در حالت DIR=RTL اين ستون در منتها اليه سمت راست جدول نشان داده می شود.

همچنين می توان از DIR برای تگ <TABLE> استفاده نکرده بلکه از آن برای تگ <TD> استفاده نمود که به نظر می رسد اين حالت در طراحی صفحات فارسی مناسبتر است و از سردرگمی برنامه نويس جلوگيری می کند.

بلوک
هرگاه در يک صفحه بلوک های داريم که دارای تگ های داخلی باشند نيازی نيست که برای تک تک آنها تعيين جهت کنيم. تعيين جهت فقط يکبار برای بلوک اصلی انجام می شود. جهت ساخت بلوکها می توان از تگهای <DIV> و <SPAN> استفاده نمود.

همه مقالات فارسی در وب را ببينيد.
جستجو: بگرد!
جستجوی پيشرفته
نام کاربری |
کلمه عبور |


IranASP.NET - رسيدگی به رويدادهای کنترلی در ASP.NET

رسيدگی به رويدادهای کنترلی در ASP.NET

مديريت سايت | اين مقاله ۵۰۴۶ بار تاکنون ديده شده است.
۱۳۸۰/۱۰/۸ | برای وبلاگ برای وبلاگ دريافت کد
نحوه پاسخگوئی به اعمال يا درخواستهای کاربر در يک صفحه ASP.NET

هنگامی که در يک فرم HTML يک دکمه (Button) فشرده (کليک) می شود، يک رويداد (Event) رخ می دهد يا هنگامی که يک ليست بازشو (ComboBox) را باز می کنيم باز هم يک رويداد اتفاق افتاده است. بنابراين يک رويداد در يک صفحه وب عبارت است از تغيير وضعيتی که در آن صفحه رخ می دهد خواه اين تغيير وضعيت، خودکار باشد يا بصورت غيرخودکار توسط کاربر رخ دهد.

از رويدادهای خودکار می توان به رويدادهای Init ، Load و Unload اشاره کرد. از موارد غيرخودکار می توان به فشردن يک دکمه در يک فرم يا خاموش / روشن کردن يک گزينه انتخابی (checkbox) اشاره نمود.

همانگونه که می دانيم دو نوع کنترل HTML و وب در ASP.NET وجود دارد. هر دو نوع اين کنترل ها می توانند سبب ايجاد رويدادی گردند. رسيدگی به يک رويداد (Event Handling) عبارت است از انجام عمل خاصی به ازای رخ دادن آن رويداد. جهت رسيدگی به يک رويداد می توان يک روال نوشت که مثلا هنگام فشرده شدن دکمه ای در يک فرم، داده های ورودی در فرم درون يک جدول در يک بانک اطلاعاتی ذخيره شوند.

رسيدگی به رويدادهای کنترل های HTML
فشردن يک دکمه HTML در يک صفحه ASP.NET سبب رخ دادن رويداد ServerClick می شود. هنگامی که فرم مذکور به روی سرور ارسال می شود، اين رويداد بر روی سرور رخ می دهد.

مثال زير نحوه رسيدگی به رويداد ServerClick را بخوبی نشان می دهد. حاصل اجرای برنامه زير نمايش وارونه متنی است که در فرم وارد شده است.

<Script runat="Server">

Sub submitText( s As Object, e As EventArgs )
mySpan.InnerHtml = StrReverse( myTextArea.Value )
End Sub

</Script>

<html>
<head><title>HtmlControlEvents.aspx</title></head>
<body>

<form runat="server">

Enter some text:
<br>
<textarea
id="myTextArea" cols="30" rows="3"
runat="Server"></textarea>

<p>
<input type="submit" value="Submit Text!"
runat="server" onServerClick="submitText">

<p>
<span id="mySpan" runat="server"></span>

</form>

</body>
</html>

در مثال فوق دکمه HTML بصورت زير تعريف شده است:

<input type="submit" value="Submit Text!"
runat="server" onServerClick="submitText">

به مشخصه onServerClick="submitText" توجه کنيد. هنگامی که بر روی دکمه مذکور کليک شود، مشخصه onServerClick سبب اجرای روال submitText می گردد.

روال submitText در يک بلوک برنامه ای در بالای صفحه تعريف شده است. اين روال متن وارد شده در textbox را گرفته و آن را بصورت وارونه به کنترل <span> منسوب می کند.

روال submitText دارای دو نوع پارامتر است: يکی از نوع object و ديگری از نوع EventArgs. پارامتر از نوع object حاوی کنترلی است که رويداد مربوطه را صادر کرده است. در مثال فوق کنترل صادر کننده رويداد، دکمه روی فرم است. پارامتر EventArgs حاوی اطلاعات مخصوصی است که ممکن است همراه رويداد ارسال گردد. در مثال فوق اطلاعاتی ارسال نمی شود.

رسيدگی به رويدادهای کنترل های وب
رسيدگی به رويدادهای کنترل های وب همانند رسيدگی به رويدادهای کنترل های از نوع HTML است. برای مثال کنترل Button يا دکمه يک رويداد از نوع Click را صادر می کند که می توان در برنامه به آن رسيدگی نمود.

مثال زير همانند مثال قبل می باشد با اين تفاوت که اين مثال برای کنترل های وب نوشته شده است.

<Script runat="Server">

Sub submitText( s As Object, e As EventArgs )
myLabel.Text = StrReverse( myTextBox.Text )
End Sub

</Script>

<html>
<head><title>WebControlEvents.aspx</title></head>
<body>

<form runat="server">

Enter some text:
<br>
<asp:TextBox
id="myTextBox"
TextMode="Multiline"
Columns="30"
Rows="3"
Runat="Server" />

<p>
<asp:Button
Text="Submit Text!"
runat="server"
onClick="submitText" />

<p>
<asp:Label
id="myLabel"
runat="server" />

</form>

</body>
</html>

در مثال فوق کنترل Button بصورت زير تعريف شده است:

<asp:Button
Text="Submit Text!"
runat="server"
onClick="submitText" />

مشخصه onClick جهت برقرار نمودن ارتباط رويداد Click مربوط به کنترل Button به روال submitText می باشد. هنگامی که بر روی کنترل Button کليک شود، اين روال بر روی سرور اجرا می گردد.

روال submitText متن وارد شده در کنترل Textarea را دريافت و پس از وارونه کردن، آن را در کنترل Label نشان می دهد.

همه مقالات فرم های وب را ببينيد.
جستجو: بگرد!
جستجوی پيشرفته
نام کاربری |
کلمه عبور |


IranASP.NET - شئ ها در ASP

شئ ها در ASP

حميد استادهاشمی | اين مقاله ۴۵۹۸ بار تاکنون ديده شده است.
۱۳۸۰/۱۰/۱۳ | برای وبلاگ برای وبلاگ
بررسى اشياء موجود در ASP 3.0 به همراه شرح هر شئ

ASP شامل تعدادى از اشياء تعبيه شده در آن است كه باعث افزايش قدرت اسكريپتها ميشود. در زير مرور مختصرى بر اشياء موجود در ASP داريم. در ASP 3.0 مجموعا دوازده شيئ وجود دارد كه شش تاى آنها بيشترين كاربرد را دارند.

Application : اين شيئ كه يكى از اشياء پر كاربرد در ASP است، براى ذخيره كردن متغيرها و نيز دستيابى به متغيرها از هر صفحه ASP استفاده ميشود. براى تمام كاربران فقط يک شيئ Application در سرور ساخته ميشود. يک Application مجموع چند صفحه ASP است كه اين صفحات، باهم، براى رسيدن به اهداف مشخصى كار مى كنند. اين شيئ، يک شيئ عمومى است و اطلاعاتى را كه مى خواهيد در چند صفحه از ASP بكار ببريد، يكجا بايد در اين شيئ ذخيره كنيد. ( مانند بانكهاى اطلاعاتى )

Session : اين شيئ نيز يكى از اشياء پر كاربرد در ASP است. شيئ Session براى ذخيره كردن اطلاعات يا تغيير تنظيمات براى هر جلسه كاربرى استفاده ميشود. هر جلسه كاربرى عبارتست از مدت زمانى كه يک كاربر از زمان ورود به يک صفحه تا زمانى كه آن صفحه را ترک ميكند صرف ميكند.
متغيرهايى كه در اين شيئ ذخيره ميشوند، اطلاعاتى را درباره يک كاربر نگه مى دارند و از همه صفحات ASP در يک پروسه كارى قابل دسترس هستند. در هنگام شروع يک جلسه كاربری، براى هر كاربر جديد، يک شيئ Session در سرور ساخته ميشود و با پايان يافتن يک جلسه كاربری، آن شيئ نيز خراب ميگردد.

Server : اين شيئ براى دسترسى به خاصيتها و متدهاى روى سرور، استفاده ميشود.

Response : از اين شيئ براى فرستادن خروجى از اطلاعات ورودى كاربر، به مرورگر استفاده ميشود. متد write كه يكى از پركاربردترين متدها در ASP است، براى نوشتن اطلاعات روى مرورگر استفاده ميشود.

Request : اين شيئ و شيئ Response معمولا باهم به كار برده ميشوند. وظيفه اين شيئ دريافت اطلاعات از كاربر است.

Dictionary : اين شيئ نيز به نوعى براى ذخيره كردن اطلاعات بكار ميرود. شما ميتوانيد به وسيله اين شيئ يک كلمه كليدى را به هر تكه از اطلاعات بچسبانيد. اين شيئ هنگام بازيابى اطلاعات، اطلاعاتى را كه شما ذخيره كرديد را به صورت Dictionary با كلمات كليدى برمى گرداند.

Drive : اين شيئ براى دستيابى به خاصيتهاى يک ديسک سخت روى شبكه استفاده ميشود.

File : اين شيئ براى دستيابى به خاصيتهاى يک فايل، مانند : Copy & Delete, Remove استفاده ميشود.

File System Object : اين شيئ براى دسترسى به فايلهاى سيستم، روى سرور استفاده ميشود. اين شيئ ميتواند فايلها، مسير فايلها و شاخه ها را دستكارى كند و اطلاعات سيستم را دريافت كند.

Folder : اين شيئ براى دسترسى به خاصيتهاى يک شاخه استفاده ميشود.

Text Stream : اين شيئ براى دسترسى به محتواى يک فايل استفاده ميشود.

ASP Error : اين شيئ يكى از ابزار ASP 3.0 است و فقط در IIS 5.0 قابل استفاده است. اين شيئ براى نمايش دادن اطلاعات دقيق، از هر اشتباه كه در پروسه اجراى اسكريپتهاى ASP رخ ميدهد استفاده ميشود. اين اطلاعات فقط به وسيله متد Server.getlasterror قابل دسترسى هستند.

اين 12 شيئ، اشياء تعبيه شده در ASP هستند كه شما تا اينجا با كار و وظيفه هر يک به طور مختصر آشنا شديد. انشاءالله در مقالات بعدى درباره متدها و خاصيتهاى هر يک از اشياء توضيحات مفصل به همراه كدهاى نمونه آورده خواهد شد.

همه مقالات ASP کلاسيک را ببينيد.
جستجو: بگرد!
جستجوی پيشرفته
نام کاربری |
کلمه عبور |


IranASP.NET - ايجاد شمارنده برای كاربران فعال در يك صفحه

ايجاد شمارنده برای كاربران فعال در يك صفحه

حميد استادهاشمی | اين مقاله ۶۵۴۷ بار تاکنون ديده شده است.
۱۳۸۰/۱۰/۲۷ | برای وبلاگ برای وبلاگ دريافت کد
طريقه ايجاد يك شمارنده برای شمارش تعداد كابران فعال در صفحه بوسيله فايل global.asa

در اين مقاله سعی داريم يك شمارنده برای شمارش تعداد كاربرانی كه در يك لحظه در يك صفحه فعال هستند درست كنيم. فايل global.asa برای يك برنامه اختياری است كه ميتواند شامل معرفی كردن اشيا، متغيرها و متدهايی باشد كه می توانند از هر صفحه در ASP دسترس پذير باشند. نكته مورد توجه در مورد اين فايل اين است كه حتما بايد اين فايل در ريشه يك برنامه ASP ذخيره شود و هر بار كه اين فايل تغيير می كند سرور به راه اندازی مجدد برای اعمال تنظيمات اين فايل نياز دارد.

در فايل global.asa چهار رويداد استاندارد وجود دارد كه عبارتند از :

• application_onstart : اين رويداد زمانی كه اولين كاربر وارد اولين صفحه از سايت شود رخ می دهد. همچنين هنگامی كه سرور reboot شود نيز اين رويداد رخ می دهد.
• application_onend : زمانی كه آخرين كاربر از سايت خارج شد و يا به عبارتی هيچ كاربر فعالی در سايت وجود نداشت اين رويداد رخ می دهد.
• session_onstart : با ورود هر كاربر به يكی از صفحات ASP اين رويداد رخ می دهد.
• session_onend : با خروج كاربر از صفحه ASP و اتمام يك جلسه كاربری اين رويداد رخ می دهد.

يك جلسه كاربری هنگامی كه كاربر ديگر صفحه ای را درخواست نكند و يا مرورگر خود را ببندد و يا به سايت ديگری برود تمام می شود.

بعد از آشنايی با اين فايل می خواهيم بوسيله آن يك شمارنده برای يك صفحه بسازيم. يك فايل بنام global.asa در ريشه درست می كنيم و كد زير را داخل آن می نويسيم.

<script language="vbscript" runat="server">
Sub Application_OnStart
Application("visitors")=0
End Sub

Sub Session_OnStart
Application.Lock
Application("visitors")=Application("visitors")+1
Application.UnLock
End Sub

Sub Session_OnEnd
Application.Lock
Application("visitors")=Application("visitors")-1
Application.UnLock
End Sub
</script>

در فايلی كه بالا ساختيم ابتدا مقدار متغير visitors را صفر قرار داديم. سپس بوسيله رويداد session_onestart با ورود هر كاربر به صفحه يك واحد به متغير visitors اضافه كرديم و در پايان نيز بوسيله رويداد session_onend با خروج هر كاربر يك واحد از متغيرمان كم كرديم. متد lock برای application برای آن است كه از تغيير دادن متغيرها بوسيله ساير كاربران جلوگيری شود. بعد از اين يك فايل با نام visitor.asp بسازيد و كد زير را در آن تايپ كنيد.

<html>
<head></head>
<body>
<p>
There are <%response.write(Application("visitors"))%>
online now!
</p>
</body></html>

در اين كد نيز بوسيله متد write از شی response مقدار متغير visitor را روی مرورگر نمايش می دهيم.

همه مقالات ASP کلاسيک را ببينيد.
جستجو: بگرد!
جستجوی پيشرفته
نام کاربری |
کلمه عبور |


IranASP.NET - تقويم هجری شمسی (جلالی)

تقويم هجری شمسی (جلالی)

اميد خندان راد | اين مقاله ۱۵۳۰۱ بار تاکنون ديده شده است.
۱۳۸۰/۱۲/۲۵ | برای وبلاگ برای وبلاگ دريافت کد
پيشنهاد وارد کردن تقويم هجری شمسی به پروژه دات نت

شرکت مايکروسافت در شالوده تکنولوژی ‪.NET‬ خود (Microsoft .NET Framework) تعدادی تقويم شامل تقويم‌های ميلادی، جولايي(رومی)، عبری، ژاپنی، کره‌ای، تايوانی، هجري-قمری و حتّی تقويم بودايي(تايلندی) را پياده‌سازی کرده است که همگی آنها عيناً در آخرين نسخه ويندوز، يعنی ويندوز XP بکار گرفته شده‌اند. همانطور که در شماره‌ی قبلی اين مقاله ديديد، در کلاس Globalization.CultureInfo در ‪.NET Class Library‬ تقويم‌های مورد استفاده در کشور ايران، تقويم ميلادی برگردان‌های فرانسوی و انگليسی و تقويم هجري-قمری تعريف شده‌اند و متأسفانه تقويم‌ هجري-شمسی علي‌رغم اينکه تقويم رسمی ايران است فراموش شده است.

اين موضوع باعث شد که من تصميم بگيرم که شـخصاً تقويم شمسی را کدنويسی کنم و آن را به مايکروسافت پيشنهاد دهم. در حال حاضر گروه تقويم مايکروسافت از وجود اين تقويم اطلاع دارد و طی يک نامه‌ی اميدوار کننده به من گفته شده که مايکروسافت در صورت دريافت تقاضاهای بيشتر و استقبال مردم از اين تقويم، آن را به فرِيم‌وُرک اصلی دات‌نت اضافه خواهد کرد. افزوده شدن تقويم شمسی به ‪.NET Framework‬ مستقيماً به معنی قرار گرفتن آن در نسخه‌های بعدی ويندوز است.

در مورد کلاس PersianCalendar
برای پياده‌سازی اين تقويم از زبان ‪C#‬ استفاده کرده‌ام. کلاس PersianCalendar از کلاس انتزاعی ‌System.Globalization.Calendar منشعب شده و از طريق آن مي‌توان به سهولت تاريخ‌ها را از(به) هجري-شمسی به(از) تمامی تاريخ‌های پشتيبانی شده توسط ديگر تقويم‌های موجود در System.Globalization (که در بالا ذکر شدند) تبديل کرد. همچنين بدليل ساختار استانداردی که اين تقويمها دارند، اگر در آينده تقويم‌های ديگری (مانند تقويم بابلي(سومری)، بيزانتين، چينی، حبشي(اتيوپی)، فصلي(زرتشتی)، يونانی، هندو، اندونزيايی، يهودی و... ) به اين مجموعه اضافه شوند، مشکلی در تبديل تاريخ (به ويا از) آنها وجود نخواهد داشت.

کلاس PersianCalendar در واقع فقط شامل منطقی است که در تقويم هجری شمسی بکار رفته و رابط کاربر(UI) آن را بايد جداگانه نوشت.

مثال: فايل پيوست اين مقاله شامل يک صفحه‌ی aspx است که با استفاده از کلاس تقويم شمسی، تاريخ هر روز را به فرم زير نمايش مي‌دهد.

امروز جمعه، دهم اسفند سال يکهزار و سيصد و هشتاد هجری شمسی
مطابق با اول مارس سال دوهزار و دو ميلادی
و هفدهم ذيحجه سال يکهزار و چهارصد و بيست و دو هجری قمری است.

من سعی خواهم کرد که در آينده مثالهای کاربردی بيشتری از اين تقويم تحت ASP.NET تهيه کنم و در اختيارتان قرار دهم.

برای دريافت برنامه‌، documentation و کد تقويم هجری شمسی به اين صفحه مراجعه کنيد. لطفاً توجه داشته باشيد که رأی و نظر شما عامل اول برای پذيرفته شدن اين تقويم است.

همه مقالات فارسی در وب را ببينيد.
جستجو: بگرد!
جستجوی پيشرفته
نام کاربری |
کلمه عبور |


IranASP.NET - فرستادن Email از طريق ASP.NET

فرستادن Email از طريق ASP.NET

شاهو طوفانی | اين مقاله ۷۳۰۰ بار تاکنون ديده شده است.
۱۳۸۱/۱/۱۵ | برای وبلاگ برای وبلاگ دريافت کد
در اين مقاله نحوه فرستادن Email از يک صفحه ASP.NET نشان داده شده است.

برای فرستادن Email از يک صفحه ASP.NET بايستی از کلاس SmtpMail که در فضانام System.Web.Mail قرار دارد استفاده کرد که شامل متد استاتيک Send است. بهرحال ساده ترين راه برای فرستادن Email فراخوانی يک نمونه متد Send از کلاس MailMessage است. کلاس MailMessage در فضانام System.Web.Email قرار دارد که پيغام Email را نشان می دهد.

کلاس MailMessage در برگيرنده خاصيتهای مشابه شئ CDONTS است ( CDONTS رايجترين شئ برای فرستادن Email در ASP کلاسيک است).

بعنوان مثال خاصيتهايی چون: Body ،Priority ،Subject ،BodyFormat ،Bcc ،Cc ،From ،To.

بهرحال برای فرستادن Email بايستی نمونه ای از کلاس MailMessage ساخته شود و خواص آن مشخص شود:

۱- ابتدا نمونه ای از کلاس MailMessage ساخته می شود:

Dim ObjMM As New MailMessage

۲- سپس آدرس email دريافت کننده:

ObjMM.To="someone@someaddress.com"

۳- آدرس فرستنده email:

ObjMM.From="someoneelse@someotheraddress.com"

۴- همچنين می توان فيلدهای Cc و Bcc را داشت:

ObjMM.Cc="someone2@someaddress.com"
ObjMM.Bcc="someone3@someaddress.com"

۵- بوسيله خاصيت BodyFormat نحوه فرستادن email بصورت text و يا html مشخص می شود:

Obj.MM.BodyFormat=MailFormat.Text

۶- خاصيت Priority ميزان Security ميل و فرستادن آنرا مشخص می کند که شامل سه انتخاب High ،Normal و Low است:

ObjMM.Priority=MailPriority.Normal

۷- خاصيت Subject عنوان ميل را مشخص می کند:

ObjMM.Subject="Hello there"

۸- بوسيله Body بدنه Email مشخص می شود ( پيغام ):

ObjMM.Body = "This is body!"

توجه داشته باشيد که فضانام System.Web.Mail در صفحه ASP.NET فراخوانی شود:

<% @import NameSpace="System.Web.Mail" %>

بعد از تعيين خواص MailMessage ، متد Send از کلاس SmtpMail برای کلاس شبيه سازی شده MailMessage بصورت زير فراخوانی می شود:

SmtpMail.Send(ObjMM)

کلاس SmtpMail برای فرستادن Email از سرويس Smtpی استفاده می کند که در ساختار IIS وجود دارد. به تعبير ديگر با بکار بردن متد Send، از سرور داخلی SMTP برای فرستادن Email استفاده می شود. برای مشخص کردن سرور SMTP از نوع ديگر ( غير از پيش فرض ) بايد خاصيت SmtpServer آن بصورت زير تعيين شود:

SmtpMail.SmtpServer= emailservername

در غير اينصورت SmtpServer پيش فرض (Default) بصورت زير است:

SmtpMail.SmtpServer=""

يکی از مهمترين کاربردهای فرستادن Email از طريق صفحات وب دريافت نظرات، اطلاعات و ... از طريق يک فرم html و ارسال آن به مدير سايت است (Feedback).

نمونه برنامه اين مقاله بطور کامل اين فرآيند را نشان می دهد.

همه مقالات کليات ASP.NET را ببينيد.
جستجو: بگرد!
جستجوی پيشرفته
نام کاربری |
کلمه عبور |


IranASP.NET - تشريح ساختمان فرم های وب

تشريح ساختمان فرم های وب

حامد بنايی | اين مقاله ۴۴۲۲ بار تاکنون ديده شده است.
۱۳۸۱/۱/۲۰ | برای وبلاگ برای وبلاگ
فرم وب در هر کدام از زبان های دات نت از يک بخش کد html و يک بخش کد به زبان مورد نظر تشکيل شده است.

فرم وب بوسيله ايجاد يک محيط ويژوال و قابليت وجود رويدادها برای اجزای فرم، شکاف بين برنامه نويسی ويژوال بيسيک و ASP کلاسيک را پر می کند.

يک فرم وب از دو قسمت تشکيل شده است: اجزای ويژوال که آنها را در هنگام طراحی می توانيد ببينيد و ديگری کدهايی که در پشت کنترل ها و صفحه ها می باشند. اجزای ويژوال در مرورگر اينترنت کاربر ديده می شود و کدهای کنترل ها و رويدادهای آنها در سرور اجرا می شوند و نتيجه به کاربر اعلام می شود. در ويژوال استوديو دات نت برای اجزای ويژوال از فايل های aspx و برای کد های آن از فايلهای vb (يا cs و کلا بسته به زبان مورد استفاده) استفاده می شود.

بوسيله تقسيم اجزای فرم وب در فايلهای مختلف و در ويژوال استوديو بوسيله نمايش آنها در پنجره های متفاوت، فرم وب يک محيطی شبيه به برنامه های معمولی ويژوال بيسيک پيدا می کند. در بيسيک قديمی ابتدا بوسيله اجزای ويژوال فرم های خود را نقاشی می کرديد و سپس کد مربوط به هر جز را می نوشتيد، در فرم وب نيز ابتدا اجزای مورد نياز خود را بر روی صفحه قرار می دهيد سپس برای آنها کد می نويسيد.

بخش کد
همانطور که ذکر شد کد هايی که برای aspx می نويسيد در فايلی با همان نام و با پسوند vb ذخيره می شود، برای ديدن اين فايلها در قسمت بالای Solution Explorer بر روی Show All Files کليک کنيد. در زير مجموعه فايلهای aspx فايلهای vb را نيز می توانيد مشاهده کنيد. بر روی فايل WebForm2.aspx.vb کليک کنيد، همانطور که مشاهده می کنيد اين فايل حاوی يک کلاس با نام WebForm2 است. اين کلاس مشتق شده از System.Web.UI.Page است، اين امر باعث می شود که صفحه از آبجکت های Response , Request , Server , Session و Application استفاده کند. برای فعال شدن رويداد های کنترل های مورد استفاده در صفحه نيز از WithEvents استفاده شده است.

يک مثال پيچيده تر
فرض کنيد بخواهيم که تقويم اين ماه را برای روی يک صفحه وب نمايش دهيم. ساختن يک تقويم پويا با استفاده از ASP کلاسيک حداقل به ۵۰ تا ۱۰۰ خط برنامه نويسی احتياج دارد. می بايست يک جدول بسازيد تا روزها را در آن نشان دهيد و يا سال و ماه را در بالای آن. بايد پيدا می کرديد که کدام روز، روز اول اين ماه است و اين ماه چند روز دارد. تمامی روزهای يک هفته را بايد در يک رديف جای دهيد و خيلی کارهای ديگر که برای نمايش تقويم ماه جاری بايد انجام دهيد. قبل از بوجود آمدن فرم وب يک راه ديگر برای انجام اين کار وجود داشت و آن استفاده از ActiveX است که مشکلات خاص خود را دارد، مانند تفاوت در مرورگرها، لزوم استفاده از سيستم عامل ويندوز، لزوم نصب شدن ActiveX و غيره. فرم وب راحتی استفاده از ActiveX و همچنين خروجی به HTML را همزمان داراست.

در پروژه HelloWorld يک فرم وب جديد اضافه کنيد. به صورت قرار دادی نام، WebForm3.aspx است، همان نام را بپذيريد و اين فرم وب را برای طراحی آماده کنيد. در toolbox به دنبال Calendar بگرديد و آن را بر روی صفحه قرار دهيد. همين !! تمامی کارهايی را که با ASP کلاسيک می بايست انجام دهيد اينجا با يک Drag & Drop انجام داديد !!

قبل از اينکه برنامه را اجرا کنيم ابتدا کمی تغييرات در شکل تقويم می دهيم تا زيبا تر شود! تغييرات زير را در خواص تقويمی که اضافه کرديد اعمال کنيد:

خاصيت مقدار
--------------------------------
ID myCal
BackColor A light yellow ( #ffffc0)
BorderColor Black
BorderStyle Solid
BorderWidth 1px
DayHeaderStyle , BackColor Light orange ( #ffc080)
DayHeaderStyle , BorderColor Dark red ( #c00000)
DayHeaderStyle , BorderStyle Inset
DayHeaderStyle , BorderWidth 1px
DayHeaderStyle , Font , Bold True
DayNameFormat Short
Font , Name Verdana
Font , Size X-Small
NextPrevFormat ShortMonth
OtherMonthDayStyle , ForeColor Silver
SelectedDayStyle , BackColor Dark blue ( #0000c0)
SelectedDayStyle , ForeColor White

فراموش نکنيد که WebForm3.aspx را به فرم اول پروژه تبديل کنيد. تمام کاری که انجام داديد استفاده از يک کامپوننت از toolbox و تغيير تعدادی از خاصيت های آن برای زيبايی بيشتر است. اين صفحه هم در Internet Explorer ديده می شود و هم در Netscape 4 به بعد.

همه مقالات فرم های وب را ببينيد.
جستجو: بگرد!
جستجوی پيشرفته
نام کاربری |
کلمه عبور |


IranASP.NET - مراحل مختلف اجرای يک فرم وب در ASP.NET

مراحل مختلف اجرای يک فرم وب در ASP.NET

حامد بنايی | اين مقاله ۴۴۲۷ بار تاکنون ديده شده است.
۱۳۸۱/۱/۲۰ | برای وبلاگ برای وبلاگ
ASP.NET مانند ASP کلاسيک به شکل تفسيری اجرا نمی شود، بلکه کامپايل شده و هر بار فايل کامپايل شده با سرعت بالايی اجرا می شود.

برنامه نويسی در محيط وب تا قبل از دات نت حتی در ASP احتياج به ساختن يک صفحه با HTML و قرار دادن کدهای مورد نياز در آن داشت. يک صفحه ASP تا قبل از ASP.NET يک متن ساده بود که از بلاک های کد ASP و بلاک های کد HTML تشکيل شده بود. در هنگام فراخوانی توسط کاربر صفحه های ASP توسط سرور خوانده شده و خط به خط دستورات آن اجرا می شد، در نهايت يک صفحه HTML به مرورگر اينترنت کاربر تحويل داده می شد.

اما فرم وب مانند يک برنامه کامل اجرا (Execute) می شود و نتيجه آن يک HTML است. همانطور که قبلا ً مشاهده کرديد فرم های وب با پسوند aspx و به صورت يک فايل متنی هستند. در يک سرور دات نت ( هر IIS Server ی که.NET Framework بر روی آن نصب شده باشد ) ، وقتی که يک مرورگر، درخواستی برای ديدن يک aspx می دهد runtime مربوط به ASP.NET آن صفحه را تجزيه و تحليل کرده و آن را کامپايل می کند. اين مرحله شبيه به نحوه کار ASP کلاسيک است، به غير از اينکه نتيجه اين کار در يک کلاس از نوع دات نت ذخيره می شود. اين کد، يک کد کامپايل شده است و مانند ASP کلاسيک نيست که به صورت تفسيری در هنگام لزوم اجرا شود. اين روش اجرا سرعت را در هنگام فراخوانی مجدد aspx بالا می برد.

به طور کلی يک پروژه برنامه اينترنتی در دات نت ( بيسيک ) حداقل يک فايل aspx و يک فايل aspx.vb دارد، که در اولی کد های HTML مانند ASP کلاسيک وجود دارد و در فايل دوم کدهايی که برای هر کدام از اجزا نوشته می شود قرار می گيرد.

به علاوه در اين نوع پروژه يک فايل Global.asax قرار دارد که مشابه Global.asa در ASP کلاسيک است. همچنين فايلی با نام Web.Config وجود دارد که با ساختار XML ذخيره شده است و اطلاعاتی درباره پروژه را در خود ذخيره می کند.

اين فايلها در دو مکان قرار می گيرند. مکان اصلی سرور اينترنتی است که برنامه بايد بر روی آن اجرا شود، همچنين يک نسخه از آن در قسمت cache ويژوال استوديو ذخيره می شود. هنگامی که در ويژوال استوديو تغييری بر روی پروژه می دهيد آن تغيير در هر دو مکان اعمال می شود.

وقتی بوسيله ويژوال استوديو می خواهيد برنامه خود را انتقال بدهيد، ويژوال استوديو مانند يک برنامه معمولی با پروژه رفتار می کند. تمامی کدهای آن را به فايل DLL تبديل می کند و هيچ سورسی انتقال نمی يابد. البته فايلهای aspx به همان شکل انتقال می يابند. در هنگام نصب نيز فايلهای DLL ی که بايد در سرور اينترنت قرار گيرند در آن جا کپی می شوند. در هنگام اجرا فايل aspx و DLL بعد از تلفيق با هم به مرورگر درخواست کننده ارسال می شود.

مثال HelloWorld را در هنگامی که فايل WebForm2 فايل اصلی بود به خاطر بياوريد. پروژه از فايلهای زير تشکيل شده است:

WebForm2.aspx
WebForm2.aspx.vb
Global.asax
Global.asax.vb
Web.Config

دقت کنيد که ما فايل Global.asax را نساخته ايم، بلکه خود ويژوال استوديو دات نت بود که اين کار را به شکل خودکار انجام داد. وقتی با کليد F5 برنامه را اجرا می کرديم فايلهای WebForm2.aspx و Global.asax مستقيما ً، بدون تغيير بر روی سرور اينترنت قرار می گرفتند. اما فايلهای WebForm2.aspx.vb و Global.asax.vb کامپايل می شوند و نتيجه در فايل HelloWorld.dll قرار می گيرد و در سرور در کنار دو فايل قبلی کپی می شود.

وقتی بوسيله مرورگر فايل aspx فراخوانده می شود، ASP.NET به صورت پويا يک فايل cls برای آن ايجاد می کند، سپس اين فايل به فايل dll کامپايل می شود. اين فايل dll در نهايت فايل HelloWorld.dll را صدا می زند و نتيجه اجرا به HTML تبديل شده و به مرورگر باز گردانده می شود.

به ياد داشته باشيد که هر برنامه ای در.NET Framework از System استفاده می کند. برنامه های اينترنتی و برای مثال aspx نيز از کلاس System.Web.UI.Page مشتق شده است. اين امر سبب می شود که در هنگامی که aspx به کلاس تبديل شود، کلاس ايجاد شده از کلاس اصلی ( system.web.ui.page ) مشتق شود. اين کلاس مفاهيمی همچون Response ، Request و... را فراهم می کند.

در ظاهر اين مراحل، اجرای يک صفحه را بسيار کند می کند، ولی تمام اينها فقط يک بار و در هنگام اولين درخواست ديدن صفحه اتفاق می افتد. فايل کلاسی که ساخته شد در مکانی ذخيره شده و تا هنگامی که آن را تغيير نداده باشيد ثابت می ماند. بنابراين در دفعات بعدی ِ فراخوانی صفحه، سرعت اجرا و نمايش آن خيلی زياد تر می شود.

همه مقالات فرم های وب را ببينيد.
جستجو: بگرد!
جستجوی پيشرفته
نام کاربری |
کلمه عبور |


IranASP.NET - کوکی در ASP کلاسيک

کوکی در ASP کلاسيک

مسلم ابراهيمی | اين مقاله ۴۳۶۳ بار تاکنون ديده شده است.
۱۳۸۱/۱/۲۴ | برای وبلاگ برای وبلاگ
آشنائی با کوکی ها و روش استفاده آنها در ASP کلاسيک

Cookie چيست؟
از يك كوكی می توان برای تشخيص كاربر استفاده كرد. کوکی يك فايل كوچك است كه سرور روی كامپيوتر كاربر قرار می دهد و هر مرتبه كه كاربر با همان مرورگر با آ ن سرور ارتباط برقرار می كند آن كوكی را نيز می فرستد. با استفاده از ASP هم می توان كوكی ايجاد كرد و هم آن ها را بازخوانی نمود.

چگونگی ساخت يك كوكی
فرمان Response.Cookies برای ساخت كوكی مورد استفاده قرار می گيرد:

<%
Response.Cookies("firstname")="Alex"
%>

ما در مثال بالا يك كوكی به اسم firstname ساخته ايم و مقدار Alex را به آن داده ايم. نكته مهم در اينجا اين است كه دستور Response.Cookies بايد قبل از برچسب <HTML> قرار گرفته باشد. همچنين می توان به يك كوكی چند صفت داد، مثل تاريخی كه بايد در كامپيوتر كاربر از بين برود:

<%
Response.Cookies("firstname")="Alex"
Response.Cookies("firstname").Expires="May 10,2002"
%>

حالا كوكی با اسم firstname مقدار Alex را دارد و در تاريخ 10 می 2002 از كامپيوتر كاربر پاك خواهد شد.

چگونگی گرفتن مقدار يك كوكی
دستور Request.Cookies برای خواندن مقدار يك كوكی مورد استفاده قرار می گيرد. در مثال زير ما مقدار كوكی firstname را بازخوانی می كنيم و آن را نمايش می دهيم:

<%
fname=Request.Cookies("firstname")
response.write("Firstname=" & fname)
%>

يك كوكی با كليدها
يك كوكی همچنين می تواند شامل مجموعه ای از مقدارهای متعدد باشد، كه در اينصورت گفته می شود كوكی دارای كليدهايی است. در مثال زير ما يك كوكی به اسم user خواهيم ساخت كه دارای كليدهايی است كه شامل اطلاعات كاربر است:

<%
Response.Cookies("user")("firstname")="Alex"
Response.Cookies("user")("lastname")="Nasser"
Response.Cookies("user")("country")="Iran"
Response.Cookies("user")("age")="20"
%>

خواندن همه كوكی ها
مثال زير تمام كوكی هايی كه سرور شما به كاربر فرستاده است را می خواند. توجه كنيد كه كد زير بررسی می كند كه آيا كليدهای كوكی دارای صفت HasKeys هستند يا نه:

<p>")
if Request.Cookies(x).HasKeys then
for each y in Request.Cookies(x)
response.write(x & ":" & y & "=" & Request.Cookies(x)(y))
response.write("<br /")
next
else
Response.Write(x & "=" & Request.Cookies(x) & "<br />")
end if
response.write "</p>"
next
%>
</body>
</html>

همه مقالات ASP کلاسيک را ببينيد.
جستجو: بگرد!
جستجوی پيشرفته
نام کاربری |
کلمه عبور |


IranASP.NET - تبديل تاريخ ميلادی به شمسی

تبديل تاريخ ميلادی به شمسی

حميد استادهاشمی | اين مقاله ۱۱۳۶۳ بار تاکنون ديده شده است.
۱۳۸۱/۱/۲۵ | برای وبلاگ برای وبلاگ دريافت کد
تبديل تاريخ ميلادی به شمسی

* * * *

توجه:

به اطلاع می رساند که بر اساس تماس های مکرر خوانندگان محترم سايت، برنامه تبديل تاريخ ميلادی به شمسی موجود در اين مقاله دارای اشکال می باشد. بر همين اساس با نويسنده محترم اين مقاله نيز تماس گرفتيم و ضمن اعلام اين مساله از ايشان خواستيم که برنامه موجود را اصلاح نمايند. اما متاسفانه ايشان تاکنون تماسی با ما نگرفته اند.

لذا ضمن پوزش از حضور شما سروران گرامی، توصيه می شود که جهت تبديل تاريخ ميلادی به شمسی می توانيد از کد زير که از وبلاگ Kernel 32 گرفته شده است استفاده نمائيد.

<%
function date_shamsi(dates,short)
D = Array (20, 19, 20, 20, 21, 21, 22, 22, 22, 22, 21, 21)
P = Array (11, 12, 10, 12, 11, 11, 10, 10, 10, 9, 10, 10)
W = Array ("&#1610;&#1705;&#1588;&#1606;&#1576;&#1607;", "&#1583;&#1608;&#1588;&#1606;&#1576;&#1607;", "&#1587;&#1607; &#1588;&#1606;&#1576;&#1607;", "&#1670;&#1607;&#1575;&#1585;&#1588;&#1606;&#1576;&#1607;", "&#1662;&#1606;&#1580;&#1588;&#1606;&#1576;&#1607;", "&#1580;&#1605;&#1593;&#1607;", "&#1588;&#1606;&#1576;&#1607;")
Mon = Array ("&#1601;&#1585;&#1608;&#1585;&#1583;&#1610;&#1606;", "&#1575;&#1585;&#1583;&#1610;&#1576;&#1607;&#1588;&#1578;", "&#1582;&#1585;&#1583;&#1575;&#1583;", "&#1578;&#1610;&#1585;", "&#1605;&#1585;&#1583;&#1575;&#1583;", "&#1588;&#1607;&#1585;&#1610;&#1608;&#1585;", "&#1605;&#1607;&#1585;", "&#1570;&#1576;&#1575;&#1606;", "&#1570;&#1584;&#1585;", "&#1583;&#1740;", "&#1576;&#1607;&#1605;&#1606;", "&#1575;&#1587;&#1601;&#1606;&#1583;")
Dm = day(dates)
Mm = month(dates)
Ym = year(dates)
U = 0
Rp = 0
if (Ym mod 4)=0 then U=1
if (Ym mod 100)=0 and (Ym mod 400)<>0 then U=0
Ys = Ym - 622
X = Ys - 22
X = X mod 33
if (((X mod 4)=0) AND X <> 32) then Rp = 1
I = (not (Rp-2)) + (not (U - 2)) * 2
X = 0
if(I = 0 AND Mm = 3) then X = 1
if(I = 0) then I = 3
Ms = (9 + Mm) mod 13
if(Ms < 10) then Ms = Ms + 1
D1 = D(Mm - 1)
if(I = 1 AND Mm > 2) then D1 = D1 - 1
if (I = 2 AND Mm < 3) then D1 = D1 - 1
P1 = P(Mm - 1)
if(I = 1 AND Mm > 2) then P1 = P1 + 1
if(I = 2 AND Mm < 4) then P1 = P1 + 1
if(Dm > 0 AND Dm <= D1) then
Ds = P1 + Dm + X - 1
X = 1
else
Ds = Dm - D1
Ms = Ms + 1
if(Ms = 13) then Ms = 1
X = 2
end if
if((Mm = 3 AND X = 2) OR Mm > 3) then Ys = Ys + 1
if(Ms<10) then Ms="0"&Ms
if(Ds<10) then Ds="0"&Ds
if short then
date_shamsi=Ys&"/"&Ms&"/"&Ds
else
date_shamsi=w(weekday(dates)-1)&" "&Ds&" "&mon(Ms-1)&" "&Ys
end if
end function
%>

* * * *

بنا به درخواستهای مكرر دوستان و علاقمندان برای دريافت برنامه تبديل تاريخ ميلادی به شمسی، تصميم برآن شد كه اين برنامه را به صورت مقاله ای در سايت IranASP.NET منتشر نمائيم تا تمامی علاقمندان به راحتی به آن دسترسی داشته باشند. برای تبديل تاريخ ميلادی به شمسی بايد چند نكته را مورد توجه قرار دهيد:

۱- سال شمسی ۶۲۲ سال با سال ميلادی فاصله دارد.
۲- ۱۱ ديماه هر سال آغاز سال ميلادی است ( مصادف با اول ژانويه است ).
۳- در هر ۳۳ سال، چهاربار كبيسه اتفاق می افتد.

تمامی نكات بالا را بايد در برنامه خود مورد توجه قرار دهيد:

<%@Language=VBScript%>
<META http-equiv=CONTENT-TYPE content="text/html; charset=utf-8">
<%
D = Array (20, 19, 20, 20, 21, 21, 22, 22, 22, 22, 21, 21)
P = Array (11, 12, 10, 12, 11, 11, 10, 10, 10, 9, 10, 10)
W = Array ("يکشنبه", "دوشنبه", "سه شنبه", "چهارشنبه", "پنجشنبه", "جمعه", "شنبه")
Mon = Array ("فروردين", "ارديبهشت", "خرداد", "تير", "مرداد", "شهريور", "مهر", "آبان", "آذر", "دی", "بهمن", "اسفند")
Dm = Day(Date)
Mm = Month(Date)
Ym = Year(Date)
U = 0
Rp = 0
If (Ym Mod 4) = 0 Then U = 1
If ((Ym Mod 100) = 0 AND (Ym Mod 400) <> 0) Then U = 0
Ys = Ym - 622
X = Ys - 22
X = X Mod 33
If ((X Mod 4) = 0 AND X <> 32) Then Rp = 1
I = Not(Rp-2) + NOT(U - 2) * 2
X = 0
If (I = 0 AND Mm = 3) Then X = 1
If I = 0 Then I = 3
Ms = (9 + Mm) Mod 13
If Ms < 10 Then Ms = Ms + 1
D1 = D(Mm - 1)
If (I = 1 AND Mm > 2) Then D1 = D1 - 1
If (I = 2 AND Mm < 3) then D1 = D1 - 1
P1 = P(Mm - 1)
If (I = 1 AND Mm > 2) Then P1 = P1 + 1
If (I = 2 AND Mm < 4) Then P1 = P1 + 1
If (Dm > 0 AND Dm <= D1) Then
Ds = P1 + Dm + X - 1
X = 1
Else
Ds = Dm - D1
Ms = Ms + 1
If Ms = 13 Then Ms = 1
X = 2
End If
If ((Mm = 3 AND X = 2) OR Mm > 3) Then Ys = Ys + 1
DateShamsi = W(WeekDay(Date) - 1) & "&nbsp;" & Ds & "&nbsp;" & Mon(Ms - 1) & "&nbsp;" & Ys
%>
<%= DateShamsi %>

پس از نوشتن اين برنامه می توانيد با فراخواندن متغير DateShamsi يك تاريخ شمسی كامل همراه با نام روز هفته را روی مرورگر نمايش دهيد.

همچنين برای راحتی كار، شما می توانيد با دو روش تاريخ شمسی را در تمامی صفحات يك سايت نمايش دهيد:
۱- كد بالا را در فايل Global.asa در قسمت Application_OnStart قرار دهيد و در هر صفحه از يك سايت تنها با فراخوانی يك متغير از نوع Application تاريخ شمسی را روی مرورگر نمايش دهيد.
۲- كد بالا را بصورت يك فايل ضميمه در تمامی صفحات يك سايت استفاده نماييد.

همه مقالات ASP کلاسيک را ببينيد.
جستجو: بگرد!
جستجوی پيشرفته
نام کاربری |
کلمه عبور |


IranASP.NET - معرفی ADO و کاربرد آن در ASP (بخش دوم – مثال)

معرفی ADO و کاربرد آن در ASP (بخش دوم – مثال)

محمد جواد سخائی | اين مقاله ۸۰۲۶ بار تاکنون ديده شده است.
۱۳۸۱/۲/۵ | برای وبلاگ برای وبلاگ دريافت کد
در اين مقاله کاربرد عملی ADO در قالب چند مثال عملی در مورد حذف، اضافه و تغيير در يک بانک اطلاعاتی نمونه تبيين شده است.

معرفی ADO و کاربرد آن در ASP (بخش اول مفاهيم)

در اين مقاله به بررسی برخی مثال های كاربردی از نحوه ارتباط ASP و ADO برای ايجاد وب سايت های متكی بر بانك های اطلاعاتی خواهيم پرداخت. قبل از پرداختن به مثال های مربوطه، در ابتدا لازم است كه يك بانك اطلاعاتی نمونه بهمراه يك جدول را تعريف كنيم. به كمك Access (نوع نسخه آن هر چيزی می تواند باشد) يك بانك اطلاعاتی با نام Students.mdb ايجاد و در آن صرفا يك جدول با نام Student كه شامل فيلدهای اطلاعاتی زير است، را تعريف می كنيم.

ID: شماره دانشجوئی يك دانشجو را در خود نگهداری خواهد كرد. فيلد فوق Primary Key خواهد بود.
FirstName: نام دانشجو را در خود نگهداری خواهد كرد.
LastName: نام خانوادگی دانشجو را در خود ذخيره خواهد كرد.
DateOfBirth: تاريخ تولد يك دانشجو را در خود نگهداری كرد.
Email: آدرس پست الكترونيكی دانشجو را در خود ذخيره خواهد كرد.

مثال ۱- بازيابی اطلاعات از بانك اطلاعاتی دانشجويان
در اين مثال جهت ارتباط با بانك اطلاعاتی از ODBC استفاده نشده است. برای بازيابی اطلاعات از بانك اطلاعاتی فوق از SQL SELECT استفاده می شود. متن برنامه بازيابی اطلاعات از بانك اطلاعاتی دانشجويان بصورت زير است.

<HTML>
<HEAD><TITLE>Student Records</TITLE></HEAD>
<BODY>
<%
Dim DBSet DB = Server.CreateObject ("ADODB.Connection")
DB.Open ("PROVIDER=Microsoft.Jet.OLEDB.4.0;DATA SOURCE=" + "C:\MyDb\Students.mdb")
Dim RSSet RS = Server.CreateObject ("ADODB.Recordset")
RS.Open "SELECT * FROM Students", DB

If RS.EOF And RS.BOF Then
Response.Write "There are 0 records."
Else
RS.MoveFirst
While Not RS.EOF
Response.Write RS.Fields ("FirstName")
Response.Write RS.Fields ("LastName")
Response.Write RS.Fields ("Email")
Response.Write "<HR>"
RS.MoveNext
Wend
End If
%>
</BODY>
</HTML>

مثال ۲- افزودن يک رکورد جديد
در اين مثال ركوردهای جديد را در بانك اطلاعاتی دانشجويان ذخيره خواهيم كرد. برای درج ركوردهای جديد در بانك اطلاعاتی می توان از INSERT INTO استفاده كرد. يكی ديگر از روش های درج ركورد در بانك اطلاعاتی استفاده از شئ RecordSet است كه بمراتب ساده تر مورد قبلی گفته شده است. در مثال فوق برای درج ركوردها در بانك اطلاعاتی از مورد دوم استفاده شده است. متن برنامه درج ركورد جديد در بانك اطلاعاتی دانشجويان بصورت زير است.

<HTML>
<HEAD>
<TITLE>Student Records</TITLE>
</HEAD>
<BODY>
<%
Dim DBSet DB = Server.CreateObject ("ADODB.Connection")
DB.Mode = adModeReadWrite
DB.Open ("PROVIDER=Microsoft.Jet.OLEDB.4.0;DATA SOURCE=" + C:\MyDb\Students.mdb")
Dim RSSet RS = Server.CreateObject ("ADODB.Recordset")
RS.Open "Students", DB, adOpenStatic, adLockPessimistic
RS.AddNew
RS ("FirstName") = "name"
RS ("LastName") = "family"
RS ("Email") = "name @domain.com"
RS ("DateOfBirth") = CDate("25 Mar, 2002")
RS.Update
%>
</BODY>
</HTML>

در مثال فوق ركورد دانشجوئی با نام "name" و نام خانوادگی "family" بهمراه آدرس پست الكترونيكی مربوطه و تاريخ تولد آن در بانك اطلاعاتی دانشجويان درج خواهد شد. اقلام اطلاعاتی مربوط به درج يك ركورد جديد را می توان با طراحی يك فرم از كاربران اخذ و پس از تكميل و ارسال فرم مربوطه، مقادير متناظر در هر يك از فيلدهای موجود در فرم اخذ اطلاعات به مقادير مربوطه در بانك اطلاعاتی نسبت داده شود (كار بسيار ساده ای است ! امتحان كنيد).

مثال ۳- بهنگام سازی ركوردهای بانك اطلاعاتی دانشجويان
در اين مثال با نحوه بهنگام سازی ركوردهای موجود در بانك اطلاعاتی دانشجويان آشنا خواهيم شد. متن برنامه بهنگام سازی ركورد دانشجوئی در بانك اطلاعاتی دانشجويان بصورت زير است.

<HTML>
<HEAD>
<TITLE>Student Records</TITLE>
</HEAD>
<BODY>
<%
Dim DBSet DB = Server.CreateObject ("ADODB.Connection")
DB.Mode = adModeReadWrite
DB.Open ("PROVIDER=Microsoft.Jet.OLEDB.4.0;DATA SOURCE=" + "C:\MyDb\Students.mdb")
Dim RSSet RS = Server.CreateObject ("ADODB.Recordset")
RS.Open "SELECT * FROM Students WHERE FirstName = ''name", DB, adOpenStatic, adLockPessimistic
RS ("Email") = "name@domain.com"
RS ("DateOfBirth") = CDate("26 Mar, 2001")
RS.Update
%>
</BODY>
</HTML>

در برنامه فوق ركورد دانشجوئی با نام "name" انتخاب و فيلدهای آدرس پست الكترونيكی (Email) و تاريخ تولد (DateIfBirth) آن تغيير و حاصل مجددا در بانك اطلاعاتی دانشجويان ثبت شده است.

مثال ۴- حذف يك ركورد
در اين مثال با نحوه حذف يك ركورد در بانك اطلاعاتی دانشجويان آشنا خواهيم شد. متن برنامه حذف يك ركورد از بانك اطلاعاتی دانشجويان بصورت زير است.

<HTML>
<HEAD>
<TITLE>Student Records</TITLE>
</HEAD>
<BODY>
<%
Dim DBSet DB = Server.CreateObject ("ADODB.Connection")
DB.Mode = adModeReadWrite
DB.Open ("PROVIDER=Microsoft.Jet.OLEDB.4.0;DATA SOURCE=" + "C:\MyDb\Students.mdb")
DB.Execute ("DELETE * FROM Students WHERE FirstName = 'name'")
%>
</BODY>
</HTML>

در مثال فوق ركورد دانشجوئی با نام "name" از بانك اطلاعاتی دانشجويان حذف شده است. در زمان حذف يك ركورد از بانك اطلاعاتی به دو نكته مهم می بايست توجه كرد: اولا امكان معروف Undo وجود ندارد. بنابراين ركوردی كه حذف می گردد، امكان برگرداندن آن وجود ندارد. ثانيا اگر در زمان اجرای DELETE ، عبارت WHERE حذف گردد، تمامی ركوردهای موجود در جدول حذف خواهند گرديد.

همه مقالات ASP کلاسيک را ببينيد.
جستجو: بگرد!
جستجوی پيشرفته
نام کاربری |
کلمه عبور |


IranASP.NET - کار کردن با کنترل DataGrid

کار کردن با کنترل DataGrid

عليرضا پورشاهيد | اين مقاله ۶۳۳۳ بار تاکنون ديده شده است.
۱۳۸۱/۳/۴ | برای وبلاگ برای وبلاگ دريافت کد
آشنائی با کنترل DataGrid جهت نمايش اطلاعات استخراج شده از بانک اطلاعاتی

اين کنترل به ما امکان نمايش اطلاعات استخراج شده از بانک اطلاعاتی به صورت جدولی را می دهد و همچنين امکاناتی نظير انتخاب، مرتب سازی، تصحيح و صفحه بندی اطلاعات را می دهد.

در حالت پيش فرض زمانی که خاصيت AutoGenerateColumns=True برقرار باشد DataGrid برای هر فيلد موجود در بانک اطلاعاتی ما يک BoundColumn می سازد در واقع به هر فيلد يک ستون اختصاص داده می شود و اطلاعات به ترتيب موجود در با نک اطلاعاتی نمايش داده می شوند. نام هر کدام از فيلدها به عنوان يک سر ستون قرار داده می شود و بقيه اطلاعات هم در زير آن قرار می گيرند. مثال زير نحوه استفاده از يک کنترل Data Grid را نشان می دهد.

در اين مثال ابتدا فضانام مربوطه يعنی System.Data را فراخوانی نموده، سپس نوع زبان مورد نظر خود برای اين صفحه را انتخاب می کنيم ( در ASP.NET می توان با زبانهای مختلف از جمله VB.NET ، #C و JS.NET برنامه نويسی کرد).

در ادامه جدولی از اطلاعات را بصورت دستی با تابع CreateDataSource می سازيم که شامل پنج ستون با مقاديری از پنج نوع مختلف می باشد. پس از ساخت ستونها به ساخت اطلاعات می پردازيم و نه سطر از آن را ايجاد می کنيم ( توسط حلقه موجود ) و پس از ايجاد هر سطر آن را به جدول اضافه می کنيم و در زيربرنامه Page_Load با استفاده از دستورات موجود مقدار جدول توليد شده را به کنترل DataGrid خود اختصاص می دهيم و سپس وارد قسمت HTML صفحه می شويم در اين قسمت نيز به بيان مشخصات کنترل گر خود می پردازيم.

<%@ Import Namespace ="System.Data" %>

<html>
<script language="VB" runat="server">

Function CreateDataSource() As ICollection

Dim dt As DataTable
Dim dr As DataRow
Dim i As Integer

'create a DataTable
dt = New DataTable
dt.Columns.Add(New DataColumn("IntegerValue", GetType(Integer)))
dt.Columns.Add(New DataColumn("StringValue", GetType(String)))
dt.Columns.Add(New DataColumn("DateTimeValue", GetType(Boolean)))
dt.Columns.Add(New DataColumn("BoolValue", GetType(Integer)))
dt.Columns.Add(New DataColumn("CurrencyValue", GetType Double)))

'Make some rows and put some sample data in
For i = 1 To 9
dr = dt.NewRow()
dr(0) = i
dr(1) = "Item " + i.ToString()
dr(2) = DateTime.Now.ToShortTimeString
If (i Mod 2 <> 0) Then
dr(3) = True
Else
dr(3) = False
End If
dr(4) = 1.23 * (i+1)
'add the row to the datatable
dt.Rows.Add(dr)
Next
'return a DataView to the DataTable
CreateDataSource = New DataView(dt)

End Function

Sub Page_Load(sender As Object, e As EventArgs)
MyDataGrid.DataSource = CreateDataSource
MyDataGrid.DataBind
End Sub

</script>
<body>

<h3><font face="Verdana">Simple DataGrid Example</font></h3>

<form runat=server>

<ASP:DataGrid id="MyDataGrid" runat="server"
BorderColor="black"
BorderWidth="1"
GridLines="Both"
CellPadding="3"
CellSpacing="0"
Font-Name="Verdana"
Font-Size="8pt"
HeaderStyle-BackColor="#aaaadd"
/>

</form>
</body>
</html>

همه مقالات فرم های وب را ببينيد.
جستجو: بگرد!
جستجوی پيشرفته
نام کاربری |
کلمه عبور |


IranASP.NET - HTTP HEADERS

HTTP HEADERS

پيمان هوشمندی راد | اين مقاله ۷۳۰۶ بار تاکنون ديده شده است.
۱۳۸۱/۳/۲۳ | برای وبلاگ برای وبلاگ دريافت کد
آشنائی با هدرهای HTTP و نوع اطلاعات همراه و نحوه بدست آوردن آنها

هدرهای Http اطلاعاتی هستند كه در پی درخواست يك صفحه وب، از سرويس گيرنده به سرويس دهنده و برعكس فرستاده می شود. به عبارت ديگر وقتی شما يك URL را درخواست می كنيد سرويس گيرنده شما به جز آدرس اينترنتی يك سری اطلاعات ديگر را كه شامل نوع مرورگر، IP ، نوع سيستم عامل و ميباشد را به سرويس دهنده ارسال می كند. همچنين وقتی سرويس دهنده درخواست شما را پس می فرستد يك مجموعه از اطلاعات مربوط به سرويس دهنده شامل مسير فيزيكی صفحه درخواست شده، نام نرم افزار سرويس دهنده وب، QueryString، و نيز همراه آن ارسال می كند كه به آنها متغيرهای محيطی يا Enviromnental Variables می گويند.

تمامی Http Header ها و متغيرهای محيطی در مجموعه ServerVariables از آبجكت Request قابل دسترسی ميباشند. دستور زير يك Http Header را به خروجی ارسال ميكند.

<%= Request.Servervariables ("نام هدر مورد نظر ") %>

مثال:

<%= Request.Servervariables ("HTTP_USER_AGENT") %>

در زير ليستی از تمامی Http Header ها و متغيرهای محيطی در Request.ServerVariables آورده شده است.

HTTP_USER_AGENT: نوع مرورگر و نوع سيستم عامل سرويس گيرنده
REMOTE_ADDR: IP كاربری كه صفحه را درخواست كرده است
HTTP_REFERER: URL صفحه ای كه از آنجا به صفحه ASP شما Link شده است
SERVER_NAME: DOMAIN NAME سايتی كه صفحه ASP شما در آن قرار دارد.
HTTP_HOST: نام كامل ميزبان وب
HTTP_COOKIE: كوكی هايی كه به مرورگر ارسال ميشود
HTTP_ACCEPT_LANGUAGE: زبانهايی كه مرورگر پشتيبانی ميكند
URL: URL صفحه ASP مابين DOMAIN NAME و QueryString
PATH_PHYSICAL_PATH: آدرس فيزيكی دايركتوری ريشه WEB
PATH_TRANSLATED: مسير فيزيكی صفحه ASP شما
QUERY_STRING: دقيقا QueryString را بر می گرداند.
SERVER_SOFTWARE: نرم افزار سرويس دهندهه وب مثل Microsoft-IIS/4.0

برای بدست آوردن تمامی Http Header ها و متغيرهای محيطی از کد زير استفاده كنيد.

<%
Dim strName
For Each strName in Request.ServerVariables
Response.Write "<Font Color=blue><B>" & strName & ": " & "</B></Font>" & _
Request.ServerVariables (strName)& "<BR>"
Next
%>

همه مقالات ASP کلاسيک را ببينيد.
جستجو: بگرد!
جستجوی پيشرفته
نام کاربری |
کلمه عبور |


IranASP.NET - ويژگی های امنيتی ASP.NET

ويژگی های امنيتی ASP.NET

مهدی ميرزايی | اين مقاله ۵۵۷۲ بار تاکنون ديده شده است.
۱۳۸۱/۴/۱۰ | برای وبلاگ برای وبلاگ
بررسی مختصر مساله امنيت در برنامه های ASP.NET در نحوه ارتباط آن با کاربر

مقدمه
امنيت يکی از مسائل اصلی برای توسعه دهندگان و معماران برنامه های کاربردی است. همانطور که تعداد بيشماری از سايتهای وب با انواع امنيت ها مورد نياز است، توسعه دهندگان نيز بايد بدانند چگونه با مقوله امنيت کار کنند و چه مدل امنيتی مناسبی برای برنامه های کاربرديشان انتخاب کنند.

بعضی از سايتهای وب اطلاعات خاصی را از کاربر معمولی دريافت نمی کنند، اما اطلاعات موجود در خود را منتشر می کنند. همانند موتورهای جستجو در حاليکه سايتهای ديگری وجود دارند که نيازمند جمع آوری اطلاعات حساس از کاربرانشان هستند (برای مثال شماره کارت های اعتباری و ديگر اطلاعات شخصی). اين سايتهای وب به پياده سازی امنيت مستحکم تری برای جلوگيری از حمله احتمالی موجوديت های خارجی نيازمندند.

تفاوت جريان امنيتی ASP و ASP.NET
جريان امنيتی صفحات ASP.NET از جريان امنيتی ASP کلاسيک متفاوت است. در ASP، بصورت پيش فرض IIS خود را به عنوان يک کاربر معتبر معرفی می نمايد در حاليکه در ASP.NET توسعه دهنده کنترل بيشتری بر روی تنظيم امنيت در سطوح مختلف را دارا می باشد.

عمليات اساسی امنيتی ASP.NET

Authentication: عبارت است از روند اعتباردهی هويت يک کاربر به پذيرفتن يا رد کردن يک درخواست، يعنی دريافت گواهی نامه ها (برای مثال نام کاربر و کلمه عبور) از کاربران و اعتبار دهی آن. بعد از اينکه هويت بررسی شد و معتبر تشخيص داده شد، کاربر بصورت قانونی مطرح می شود و درخواست های دسترسی به منابع انجام می شود. بصورت ايده آل درخواست های آتی همان کاربر تا هنگام خروج از سيستم مرتبط با روند Authentication نيست.

Authorization: عبارت است از روند تضمين نمودن اينکه کاربران با هويت های معتبر مجاز به دسترسی به منابع مشخصی هستند.

Impersonation: اين روند يک برنامه کاربردی را قادر می سازد تا به نوبت هويت کاربر و درخواستهای بعدی او برای ساير منابع را تضمين کند. دسترسی به منابع متناسب با هويت کاربری که جايگزين شده است (Impersonated) تاييد يا رد می گردد. به عبارت ديگر Impersonation يک پروسه سرويس دهنده (Server Process) را قادر می سازد تا با استفاده از امنيت گواهی نامه سرويس گيرنده ها (Client) اجرا شود.

همه مقالات کليات ASP.NET را ببينيد.
جستجو: بگرد!
جستجوی پيشرفته
نام کاربری |
کلمه عبور |


IranASP.NET - ورود اطلاعات فارسی با استفاده از جاوااسکريپت

ورود اطلاعات فارسی با استفاده از جاوااسکريپت

رحمان حق پرست | اين مقاله ۷۷۶۶ بار تاکنون ديده شده است.
۱۳۸۱/۴/۲۴ | برای وبلاگ برای وبلاگ
در اين مقاله به نحوه ورود اطلاعات فارسی از طريق فرمهای HTML با استفاده از يک تابع جاوااسکريپت در کار با Access و ASP پرداخته شده است.

اگر قبلا اقدام به استفاده از زبان فارسی در كدهای خود و مخصوصا هنگام كار با Microsoft Access كرده باشيد به احتمال زياد با مشكلات موجود بر سر راه آشنا هستيد. يكی از مشكلات اساسی بر سر راه استفاده از زبان فارسی در بانكهای اطلاعاتی Microsoft Access در نحوه ورود اطلاعات می باشد. برای درك بهتر اين موضوع اينگونه عمل نماييد:

در ويندوز خود قابليت فارسی نويسی را فعال نماييد و پس از آن در Access يك Table با نام test وبا يك فيلد به نام test از نوع text ايجاد نماييد. سپس با استفاده از خود Access اطلاعاتی به زبان فارسی وارد نماييد. سپس از Access خارج شده و با استفاده از ASP به بانك اطلاعاتی Access متصل شده و اطلاعات وارد شده را خوانده و نمايش دهيد. مشاهده خواهيد نمود كه اطلاعات نمايش داده شده داخل مرورگر با اطلاعات وارد شده توسط شما در داخل Access متفاوت می باشد.

برای حل اين مشكل چه بايد كرد؟
برای حل اين مشكل بايد اطلاعات از خارج از Access و با استفاده از ASP و يك تابع Javascript كه صفحه كليد را در همه ويندوزها اعم از فارسی و انگليسی، فارسی نموده و امكان تايپ فارسی را فراهم ميكند، وارد شوند. روش كار به اين صورت است كه در يك فرم HTML و در داخل يك Input Box هنگام فشرده شدن هر كليدی از صفحه كليد، تابع Javascript فرا خوانده شده و معادل فارسی حرف وارد شده را نمايش ميدهد. برای نمايش حروف فارسی لازم است كه از charset=windows-1256 استفاده نماييد. فونت صفحه را نيز يكی از دو فونت Times New Roman و يا Tahoma انتخاب نماييد. اين دو فونت فونتهای استاندارد ويندوز بوده و برای ديده شدن متون فارسی نيازی به نصب فونت جديد روی سيستم کاربر نخواهد بود. Javascript استفاده شده در زير آمده است:

#$%،گ)(+و-./0123456789:ك,=.؟@ِذ}ىُىلآـ،/د؛َءٍف{ًْإ~جژچ^_پشذزيثبلاهتنمئدخحضقسفعرصطغظ<|>ّ'.charCodeAt(key-32);
else if (e)
e.which=' !"#$%،گ)(+و-./0123456789:ك,=.؟@ِذ}ىُىلآـ،/د؛َءٍف{ًْإ~جژچ^_پشذزيثبلاهتنمئدخحضقسفعرصطغظ<|>ّ'.charCodeAt(key-32);
}
return true;
}
//-->
</SCRIPT>

پس از طراحی فايل HTML نوبت به ايجاد فايل ASP می رسد. در فايل ASP بايد اطلاعات وارد شده در فرم HTML را دريافت نموده و در بانك اطلاعاتی Access توسط برنامه خود بنويسيد. نكته جالب اين است كه اگر وارد Microsoft Access شويد و اطلاعات وارد شده توسط برنامه خود را مشاهده نماييد اثری از حروف فارسی مشاهده نخواهيد کرد. حال اگر دوباره توسط برنامه ASP اوليه به بانك اطلاعاتی متصل شويد و اطلاعات دريافت شده را داخل مرورگر نمايش دهيد اطلاعات به صورت فارسی نمايش داده ميشوند. لازم به ذكر است كه بايد از charset=windows-1256 در فايل ASP كه اطلاعات فارسی را نمايش ميدهد استفاده نماييد.

همه مقالات ASP کلاسيک را ببينيد.
جستجو: بگرد!
جستجوی پيشرفته
نام کاربری |
کلمه عبور |


IranASP.NET - ارسال نامه در ASP.NET

ارسال نامه در ASP.NET

عليرضا پورشاهيد | اين مقاله ۷۲۸۱ بار تاکنون ديده شده است.
۱۳۸۱/۵/۱ | برای وبلاگ برای وبلاگ دريافت کد
در اين مقاله ياد خواهيم گرفت که چگونه می توان از طريق يک صفحه ASP.NET يک Email فرستاد.

يکی از پر کاربردترين سرويسها بر روی اينترنت ارسال email می باشد که ميخواهيم به آن بپردازيم. در دات نت برای اين عمل بايد از نامکده System.Web.Mail استفاده نمايم و به منظور وارد کردن آن از کد زير استفاده مينمايم.

<%@ Import Namespace="System.Web.Mail" %>

همانطور که می دانيد در زبانهای شئ گرا برای استفاده از اشيا بايد ابتدا از آنها يک کپی يا در اصطلاح Instance برداشت به اين منظور از کد زير استفاده می نماييم.

Dim mail As New MailMessage

حال نوبت به استفاده از خواص و متدهای شئ کپی برداری شده می باشد، که اجزا مهم آن به شرح زير می باشد:

mail.From: آدرس فرستنده email
mail.To: آدرس گيرنده email
mail.Subject: موضوع
mail.Body: متن email که می تواند به صورت HTML باشد
mail.BodyFormat: نوع ساختار متن را مشخص می کند
SmtpMail.SmtpServer: سرويس دهنده محلی (Local) شما می باشد
SmtpMail.Send(mail): متد برای ارسال در انتهای کار

در اينجا يک مثال مشاهده می کنيد که با استفاده از فرم و دکمه Submit يک آدرس پست الکترونيکی را دريافت کرده و پيام پيش فرض را به آن ارسال می دارد. توجه داشته باشيد که در اينجا از يک صفحه برای هر دو عمليات دريافت آدرس و ارسال استفاده شده و با استفاده از يک کنترل Label که از کنترل های سرور در دات نت می باشد نشان ميدهيم که در حال دريافت آدرس هستيم يا ارسال.

<%@ Page Language="VB" EnableSessionState="False" EnableViewState="False" Trace="False" Debug="False" Strict="True" %>
<%@ Import Namespace="System.Web.Mail" %>
<script language="VB" runat=server>
Sub Page_load(Sender as Object, E as EventArgs)

If request.form("EmailAddress") = "" Then
dim strResponse as string = "<h2>Send Email using ASP.NET formatted in HTML</h2>"
lblMessage.Text = strResponse
Else
dim strResponse as string = "You just sent an email message formatted in HTML to:<br><h2>" &request("EmailAddress") & "</h2>"
lblMessage.Text = strResponse
End If

End Sub

Sub btn_Click(sender as Object, e as System.EventArgs)
If request.form("EmailAddress") <> ""
Dim mail As New MailMessage
mail.From = youraddress@domain.com
mail.To = request.form("EmailAddress")
mail.Subject = "Message sent using ASP.NET and CDONTS"
mail.Body = "HTML Message sent from Iranasp.net using ASP.NET and Cdonts<br>Wonder how this is done?<br><br>Wonder How to setup CDONTS?"
mail.BodyFormat = MailFormat.Html
SmtpMail.SmtpServer = "LocalServerName"
SmtpMail.Send(mail)
End If
End Sub
</script>
<html>
<head>
</head>
<body>
<h1 align="center">Sending Email via ASP.NET and CDONTS..</h1>
<b>How do I setup my server to use CDONTS?</b>
<br/>
<br/>
<br/>
<br/>
<asp:Label id="lblMessage" Font-Name="Verdana" Width="400px" BorderStyle="solid" BorderColor="#cccccc" runat="server"/>
<form method="post" name="form1" runat="server" runat="server">
Email Address:<input type="text" name="EmailAddress" size="30" value=""><br><br>
<input type="Submit" id="btnSubmit" OnServerClick="btn_Click" value="Sending Email with ASP.NET" name="b1" runat="server" />
</form>
</body>
</html>

همه مقالات کليات ASP.NET را ببينيد.
جستجو: بگرد!
جستجوی پيشرفته
نام کاربری |
کلمه عبور |


IranASP.NET - سيستم پرداخت Authorize.Net

سيستم پرداخت Authorize.Net

مهدی ميرزايی | اين مقاله ۵۸۴۳ بار تاکنون ديده شده است.
۱۳۸۱/۵/۱۳ | برای وبلاگ برای وبلاگ دريافت کد
استفاده نمودن از ASP يا ASP.Net و XMLHTTP برای برقراری ارتباط با Authorize.Net

Authorize.Net يک دروازه (Gateway) سيستم پرداخت (Payment) شبيه به Verisign's Payflow pro است. Authoriz.Net چندين محصول مختلف و محدوده سرويس های مختلفی از يک پايانه مجازی تا فرم های پرداخت را معرفی می نمايد.

برخلاف چندين دروازه ديگر، توسعه دهندگان امکان انتخاب چگونگی پياده سازی سرويس های Authorize.Net را دارا می باشند. شما به سادگی می توانيد کاربر را به يک فرم بر روی سايت Authorize.Net (چيزی که آنها آن را WebLink می نامند) بفرستيد. شما فرم تان را می توانيد به يک صفحه در سايت Authorize.Net بفرستيد که يک صفحه تشکر آميزی که شما از سايتتات مشخص کرديد می گيرد و به کاربرانتان نشان می دهند (که آن را Relay Response می نامند)، يا اينکه شما می توانيد از نرم افزار شخص ثالث (3rd party) برای ارسال نمودن به سرويس دهنده هاشان و دريافت مقادير بازگشتی و سپس انجام دادن هر آنچه شما نياز داريد در اسکريپتتان، استفاده نماييد (که آن را Direct Response می نامند).

بدين صورت ما می توانيم درخواست خود را به يک برنامه ISAPI Dll ارسال نماييم بر روی سايت ذکر شده و سپس خروجی آن را تجزيه و تحليل نماييم. ارسال درخواست در صفحه ASP يا ASP.Net با استفاده از شی Microsoft.XMLHTTP ميسر می باشد.

کد زير نشان دهنده چگونگی کار است :

<HTML>
<BODY>
<FORM METHOD=post ACTION="orderScript.asp">
Description: <INPUT name=x_Description value="Qty 24 - Yellow Note Pads"><br>
Amount: <INPUT name=x_Amount value="4.95"><br>
Credit Card Number: <INPUT name=x_Card_Num value="4111111111111111"><br>
Expiration Date: <INPUT name=x_Exp_Date value="102003"><br>
First Name: <INPUT name=x_First_Name value="Fred"><br>
Last Name: <INPUT name=x_Last_Name value="Consumer"><br>
Address: <INPUT name=x_Address value="1500 N. Scenic Dr."><br>
City: <INPUT name=x_City value="Hollywood"><br>
State: <INPUT name=x_State value="CA"><br>
Zip Code: <INPUT name=x_ZIP value="90201"><br>
Phone: <INPUT name=x_Phone value="800-555-1212"><br>
Fax: <INPUT name=x_Fax value="800-555-1213"><br>
Email: <INPUT name=x_Email value="fred@testmail.com"><br>
<INPUT type=submit value=Submit name=submit>
</FORM>
</BODY>
</HTML>
<HTML>
<BODY>
<%
'First enter our loginID
PostData = "x_Login=testdrive" 'test account for Authorize.Net
PostData = PostData & "&x_Version=3.0"
PostData = PostData & "&x_Test_Request=TRUE" 'since we are testing
PostData = PostData & "&x_ADC_Delim_Data=TRUE" 'we want comma delimited
PostData = PostData & "&x_ADC_URL=FALSE" 'do not want to redirect

'Now add the form fields
PostData = PostData & "&x_Card_Num=" & Request.Form("x_Card_Num") & ""
PostData = PostData & "&x_Exp_Date=" & Request.Form("x_Exp_Date") & ""
PostData = PostData & "&x_Description=" & Request.Form("x_Description") & ""
PostData = PostData & "&x_Amount=" & Request.Form("x_Amount") & ""
PostData = PostData & "&x_First_Name=" & Request.Form("x_First_Name") & ""
PostData = PostData & "&x_Last_Name=" & Request.Form("x_Last_Name") & ""
PostData = PostData & "&x_company=" & Request.Form("x_company") & ""
PostData = PostData & "&x_Address=" & Request.Form("x_Address") & ""
PostData = PostData & "&x_City=" & Request.Form("x_City") & ""
PostData = PostData & "&x_State=" & Request.Form("x_State") & ""
PostData = PostData & "&x_ZIP=" & Request.Form("x_ZIP") & ""
PostData = PostData & "&x_Phone=" & Request.Form("x_Phone") & ""
PostData = PostData & "&x_Fax=" & Request.Form("x_Fax") & ""
PostData = PostData & "&x_Email=" & Request.Form("x_Email") & ""

'Send the transaction info as part of the querystring
set xml = Server.CreateObject("Microsoft.XMLHTTP")
xml.open "POST", "https://secure.authorize.net/gateway/transact.dll?" _
& PostData & "", false
xml.send ""
strStatus = xml.Status
strRetval = xml.responseText
set xml = nothing

'Response.Write "response = " & strRetVal & "<BR>" 'this will print out the
'entire return string
'for troubleshooting

'first we'll create an array from the return value by splitting on the
'commas and then we'll assign each member of the array to values that
'better describe them for the reader. Of course we'd probably want to
'do something else with these values like save them to a database,
'create an email to send to the webmaster and/or the user

strArrayVal = split(strRetVal, ",", -1)
x_response_code = strArrayVal(0)
'Response Code:
'1 = This transaction has been approved.
'2 = This transaction has been declined.
'3 = There has been an error processing this transaction.

x_response_subcode = strArrayVal(1)
x_response_reason_code = strArrayVal(2)
x_response_reason_text = strArrayVal(3)
x_auth_code = strArrayVal(4) '6 digit approval code
x_avs_code = strArrayVal(5)
'Address Verification system:
'A = Address (street) matches, Zip does not
'E = AVS error
'N = No match on address or zip
'P = AVS Not Applicable
'R = Retry, system unavailable or timed out
'S = service not supported by issuer
'U = address information is unavailable
'W = 9 digit Zip matches, address does not
'X = exact AVS match
'Y = address and 5 digit zip match
'Z = 5 digit zip matches, address does not

x_trans_id = strArrayVal(6) 'transaction id
x_invoice_num = strArrayVal(7)
x_description = strArrayVal(8)
x_amount = strArrayVal(9)
x_method = strArrayVal(10)
x_type = strArrayVal(11)
x_cust_id = strArrayVal(12)
x_first_name = strArrayVal(13)
x_last_name = strArrayVal(14)
x_company = strArrayVal(15)
x_address = strArrayVal(16)
x_city = strArrayVal(17)
x_state = strArrayVal(18)
x_zip = strArrayVal(19)
x_country = strArrayVal(20)
x_phone = strArrayVal(21)
x_fax = strArrayVal(22)
x_email = strArrayVal(23)
x_ship_to_first_name = strArrayVal(24)
x_ship_to_last_name = strArrayVal(25)
x_ship_to_company = strArrayVal(26)
x_ship_to_address = strArrayVal(27)
x_ship_to_city = strArrayVal(28)
x_ship_to_state = strArrayVal(29)
x_ship_to_zip = strArrayVal(30)
x_ship_to_country = strArrayVal(31)
x_tax = strArrayVal(32)
x_duty = strArrayVal(33)
x_freight = strArrayVal(34)
x_tax_exempt = strArrayVal(35)
x_po_num = strArrayVal(36)
x_md5_hash = strArrayVal(37)
%>

<H1>Order Receipt</H1>
<%
'Check the ErrorCode to make sure that the component was able to talk
'to the authorization network
If (strStatus <> 200) Then
Response.Write "An error occured during processing. " _
& "Please try again later."
else
If x_response_code = 1 Then
Response.Write("Thank you for your purchase.")
elseif x_response_code = 2 then
Response.Write("The transaction was not approved: " _
& x_response_reason_text)
Else
response.Write "An error occured during processing. " _
& "Please try again later."
End If
end if
%>

</BODY>
</HTML>

همه مقالات ASP کلاسيک را ببينيد.
جستجو: بگرد!
جستجوی پيشرفته
نام کاربری |
کلمه عبور |


IranASP.NET - متغيرهای ايستا در ASP.NET

متغيرهای ايستا در ASP.NET

عليرضا پورشاهيد | اين مقاله ۴۸۱۵ بار تاکنون ديده شده است.
۱۳۸۱/۵/۲۲ | برای وبلاگ برای وبلاگ
آشنائی با متغيرهای ايستا در ASP.NET از طريق کاربرد آن در فايل Global.asax.

در ASP همواره از شئ Application برای ذخيره متغيرهای سراسری استفاده می شد. اين عمل از لحاظ اختصاص فضای حافظه چندان مناسب نبود. در دات نت می توانيم با سود بردن از خواص متغيرهای ايستا در اکثر موارد نتيجه بهتری بدست آوريم. اين روش در اکثر موارد سريعتر از استفاده از شئ Application خواهد بود.

در دات نت اکثر اشياء به صورت کلاس در نظر گرفته می شوند که فايل global.asax نيز از اين قائده پيروی می کند. برای استفاده از اين روش در ابتدا بايد به اين فايل نام يک کلا س را اختصاص دهيم. دقت کنيد که هميشه سعی می کنيم در نامگذاری از اسامی که راهنمای ما باشند استفاده کنيم. برای مثال در اينجا از نام myglobal استفاده می کنيم. به منظور انجام اين کار از کد زير استفاده می شود.

<%@ Application Classname="MyGlobals" %>

سپس با استفاده از تگ Script متغيرهای خود را تعريف می نماييم. دقت کنيد که بايد از کلمات کليدی Public و Shared هم استفاده نما ييد.

<Script language="vb" runat="server">
Public Shared sAli as String = "This is just a test"
</Script>

با کد بالا ما متغير خود را به نام sAli تعريف نموديم. حال با استفاده از نام کلاس و اين نام می توا نيم آن را در تمام صفحات خود به صورت مستقيم صدا کنيم.

x = MyGlobals.sAli

کدهای نمونه را می توانيد مشاهده کنيد.

<%@ Application Classname="MyGlobals" %>

<Script language="vb" runat="server">

Public Shared sGreeting as String = "This is just a test"

</Script>
<% @Page Language="VB" %>
<HTML>
<HEAD>
<script Language='vb' runat=server>
Private Sub Page_Load(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles MyBase.Load
Label1.Text = MyGlobals.sGreeting
End Sub
</script>
</HEAD>
<body>
<asp:label runat=server id=Label1></asp:label>
</body>
</HTML>

همه مقالات آشنايی با VB.NET را ببينيد.
جستجو: بگرد!
جستجوی پيشرفته
نام کاربری |
کلمه عبور |


IranASP.NET - ASP.NET و پايگاه داده – قسمت اول

ASP.NET و پايگاه داده – قسمت اول

شاهو طوفانی | اين مقاله ۹۳۱۸ بار تاکنون ديده شده است.
۱۳۸۱/۵/۲۸ | برای وبلاگ برای وبلاگ
در این مجموعه شما با اصول وروشهای استفاده از پایگاه داده در ASP.NET آشنا می شوید.

در اين مقاله شما در مورد کار با با پايگاه داده در ASP.NET آشنا خواهيد شد. بدين معنا که در صدد هستيم تا رويه ای کلی از مفاهيم، روشها وابزارهای مورد استفاده در ASP.NET جهت برقراری ارتباط با پايگاه داده، نشان دادن داده ها، دستکاری داده ها، بهنگام سازی و... توسط اشيايی چون مهيا کننده های بانک های اطلاعاتی، DataSetها XML، و ... معرفی می شود.

اگر تا بحال با پايگاه داده کار نکرده ايد شايد provider يک پايگاه داده برای شما نامفهوم باشـد. بطور خلاصه راهی را که بايد طی کرد تا به پايگاه داده متصل شده، آنرا باز کرده و داده ها را دستکاری کرده و دستورات را اجرا نمود، بوسيله يک تهيه کننده اطلاعات مشخص می شود. در ASP.NET معمولا از دو روش برای اين کار استفاده می شود. روش اول اينکه اگر پايگاه داده شما از نوع SQL Server باشد بايستی با مدل SQLClient کار کرد و اگر پايگاه داده شما غير از SQL Server باشد (در حال حاضر) بايد از روش ديگر يعنی مدل OleDb استفاده نمود. بعنوان مثال اگر پايگاه داده شما Oracle ،Sybase و يا Access باشد بايد از روش OleDb استفاده کنيد.

روش کار بدين صورت است که ابتدا بايستی فضانام زير را در صفحاتی که از بانک اطلاعاتی استفاده می شود فراخوانی کرد:

<% @ Import NameSpace="System.Data" %>
<% @ Import NameSpace="System.Data.OleDb" %>

برای برقراری ارتباط با پايگاه معمولا از عبارت زير استفاده می شود:

Dim ObjConn As New OleDbConnection("Provider=Microsoft.Jet.OLEDB.4.0; DataSource=e:\db\users.mdb")

که قسمت DataSource آدرس فايل پايگاه داده است که در اينجا يک بانک Access است. همانگونه که ملاحظه می کنيد از رشته ارتباطی يا Connection String بعنوان پارامتر استفاده شده است و بوسيله متد Open ارتباط باز می شود:

objConn.Open()

لازم به توضيح است که در پايان کار بوسيله متد Close ارتباط را خاتمه می دهيم.

بمحض ارتباط با پايگاه داده می توان دستورات را به آن فرستاد. اين کار معمولا بوسيله شی OleDbCommand انجام می شود. جهت انجام اين کار می توان يک دستور SQL يا نام يک روال ذخيره شده (Stored Procedure) را مشخص نمود و بنا به مقتضيات می توان اعمال مختلفی را روی پايگاه پياده نمود:

Dim objCommand As New OleDbCommand ( "Select * From users", objConn )

ملاحظه می کنيد که کلاس Command از دو پارامتر رشته SQL و نام رشته ارتباطی برای فرستادن دستورات به پايگاه داده استفاده می کند. برای مثال آنچه را که در عبارت فوق ديديد می توان به بخشهای کوچکتر زير تقسيم کرد.

ابتدا تعريف شي:

Dim objCommand As New OleDbCommand()

سپس نسبت دادن آن به رشته ارتباطی جهت برقراری ارتباط پايگاه:

objCommand.Connection= objConn

مشخص کردن عمليات مورد نظر بوسيله دستورات SQL:

objCommand.CommandText="Select * From Users"

حتی می توانيد عمليات فوق را بصورت ذيل انجام دهيد:

Dim objCommand As New OleDbCommand( SQL string, Connection string )

روشهای فوق دقيقا يک کار مشابه را انجام می دهند با اين اوصاف که در عبارت آخر بجای شئ ارتباطی از يک رشته ارتباطی استفاده شده است. تا اين مرحله هنوز عبارات فوق را به اجرا در نياورده ايم. برای اين کار راه های متفاوتی وجود دارد:

- از ExecuteNonQuery زمانی استفاده می شود که قصد برگرداندن داده ها از پايگاه مورد نظر نباشد مثلا در مواقعی که از دستورات SQL جهت درج (Insert) و بهنگام سازی (Update) استفاده شود.

objCommand.ExecuteNonQuery

- از ExecuteReader برای خواندن و برگرداندن اطلاعات از پايگاه استفاده می کنيم.

Dim ObjRead As OleDbDataReader
objRead=objCommand.ExecuteReader

- برای دستکاری يک تک مقدار مشخص و مورد نظر از متد ExecuteScalar استفاده می شود.

برای خواندن داده ها معمولا از کلاس DataReader استفاده می شود -برای خواندن نه برای اضافه کردن يا بروز کردن- اين شئ بصورت مستقيم به پايگاه داده دسترسی دارد و فقط خواندنی (Read Only) است. البته اين خاصيت محدوديتی برای آن است اما برای خواندن ساده داده روشی کامل بشمار می رود.

Dim objReadaer As OleDbDataReader
objReader=objCommand.ExecuteReader
Whlie objReader.Read
Response.write(objReader.GetString(0)& " <br> " )
End While

عبارت فوق جهت نمايش و چاپ داده ها بکار می رود. متد Read خواندن را تا زمانيکه به پايان نتايج نرسد ادامه می دهد و عبارت objReader.GetString(0) برای برگرداندن نسخه رشته ای ستونهای رکورد کاربرد دارد. در ليست زير چند متد ديگر برای برگرداندن مقادير داده ای متغيرها آمده است:

GetBoolean(x) مقدار منطقی را بر می گرداند.
GetChar(x) مقدار کاراکتری را برمی گرداند.
Get DataTypeColumn(x) نوع داده را در ستون برميگرداند.
GetString(x) مقداررشته ای را برمی گرداند.
و...

قسمت دوم

همه مقالات ADO.NET و پايگاه داده را ببينيد.
جستجو: بگرد!
جستجوی پيشرفته
نام کاربری |
کلمه عبور |


IranASP.NET - Smart Navigation چيست؟

Smart Navigation چيست؟

محمود مروج | اين مقاله ۵۸۳۲ بار تاکنون ديده شده است.
۱۳۸۱/۶/۱۲ | برای وبلاگ برای وبلاگ
اين مقاله به توضيح مفهوم smart navigation(هدايت هوشمندانه!) و چگونگى استفاده از آن مى پردازد.

مفهوم Smart Navigation و فوايد آن
Smart Navigation يكى از بهترين ابزارهاى جديدى است كه ASP.NET آنرا عرضه كرده است. اين ابزار جديد باعث شده ظاهر برنامه هاى وب و احساسى كه نسبت به آن وجود دارد شباهت بيشترى با برنامه هاى عادى و نوشته شده براى ويندوز پيدا كند.

يكى از موانع بزرگ برنامه هاى تحت وب به معمارى و ساختار HTTP برمى گردد. جاييكه مجبوريم اطلاعات جمع آورى شده در سمت مشترى را به سرور بازگردانيم. به همين دليل مجبور به رسم مجدد و كامل صفحه اى كه قبلا ديده ايم مى باشيم، كه اين نه تنها باعث مى شود يك حالت فلش مانند در اين رفت و برگشت و رسم مجدد رخ دهد، بلكه براى صفحه هاى بلند كه براى ديدن تمام صفحه نيازمند بهscrolling هستيم، باعث مى شود كه ديدمان را به اول صفحه انتقال دهد، چيزى كه هم شايد دلخواه ما نباشد و هم اينكه ممكن است باعث سردرگمى كاربر گردد. همچنين اين فرآيند باعث تغيير فوكوس كنترل ها و بسيارى از اتفاقات ديگرنيز مى شود.

در برنامه هاى عادى ويندوز ما به طور معمول فقط قسمت هايى از صفحه را به روز مى كنيم كه تغييرى در آن ايجاد شده باشد يا تحت تاثير چيزى قرار گيرند و اين بدون نياز به تغيير در كل برنامه مى باشد (مثلا فقط يك عضو به listbox ما اضافه مى شود. بدون تغيير و رسم مجدد فرم برنامه).

Smart Navigation يا به عبارتى هدايت هوشمندانه اين توانايى موجود در برنامه هاى ويندوز را براى برنامه هاى تحت وب فراهم مى كند! اما قبل از هر چيز بايد بدانيد كه اين ابزار فقط براى IE مى باشد و آن هم نسخه هاى ۵ به بالاتر آن. با اين وجود شما مى توانيد Smart Navigation را فعال يا غيرفعال سازيد، بدون آنكه تاثيرى در برنامه شما بگذارد. حتى اگر شما در پروژه تان مرورگرهاى محتلفى را مدنظر قرار داده باشيد، مى توانيد Smart Navigation را فعال سازيد. در اين صورت ASP.NET نوع مرورگر را تشخيص داده و Smart Navigation را فقط براى مرورگرهاى پشتيبانى شده فعال مى سازد.

چهار مورد برجسته اى كه Smart Navigation فراهم مى كند عبارتند از:

• صفحه در ميان درخواست ها يك نمايش ممتد را داراست و به عبارتى حالت فلش زدن به خود نمى گيرد.
• موقعيت Scroll را حفظ مى كند.
• فوكوس عضو دارنده فوكوس را نگه مى دارد.
• آخرين صفحه درون تاريخچه (History) نگهدارى مى شود.

اين ابزار در حالت واقع گرايانه براى برنامه هايى كه ارسال به عقب(!) Postback فراوانى دارند طراحى شده است ولى با توجه به اين نكته كه محتواى صفحه نبايد زياد تغيير نكند. احتمالا بنا به دلايل كارايى و نه اينكه در تغييرات زياد ايرادى بهم بزند - مترجم. شايد يك چيز شگفت آور در مورد اين ابزار اين باشد كه شما در حقيقت نياز به نوشتن هيج كد و برنامه اى نداريد.

نحوه استفاده
Smart Navigation درون هدايت كننده صفحه (Page directive : <%@ %>)، براى تنظيم يك صفحه و درون web.config براى تنظيم كل برنامه استفاده مى شود. براى تنظيم در Page Directive به صورت زير عمل كنيد:

<%@ Page SmartNavigation=true %>

و براى تنظيم در web.config از ساختار زير استفاده نماييد:

<Configuration>
<System.web>
<Pages SmartNavigation=true />
</System.web>
</Configuration>

روش كار اينگونه است كه كل صفحه بدرون يك فريم دورنى مخفى (hidden IFrame) بارگذارى (load) مى شود و سپس فقط قسمت هاى تغيير كرده دوباره رندر(render) مى شوند.

برگرفته از كتاب Professional ASP.NET 1.0 انتشارات Wrox

همه مقالات کليات ASP.NET را ببينيد.
جستجو: بگرد!
جستجوی پيشرفته
نام کاربری |
کلمه عبور |


IranASP.NET - آشنايی با Visual Basic.NET- متغيرها

آشنايی با Visual Basic.NET- متغيرها

مديريت سايت | اين مقاله ۶۱۲۴ بار تاکنون ديده شده است.
۱۳۸۱/۶/۱۹ | برای وبلاگ برای وبلاگ
آشنائی با مفهوم متغير و انواع آن با در نظر گرفتن لايه های داده ای موجود در VB.NET

متغيرها حاملهای دربرگيرنده مقاديری هستند که در جريان يک برنامه کاربردی می توانند تغيير کنند. برنامه نويسی بدون آنها، اگر نگوئيم غيرممکن، اما به سختی امکان پذير است. در ASP.NET، متغيرها در چند لايه وجود دارند.

لايه اول، لايه Application است. در اينجا در هر صفحه برنامه کاربردی، همه متغيرها در دسترس همه کاربران قرار دارد. معمولا يک قطعه داده نسبتا کوچک که در معرض استفاده مکرر است، همانند اطلاعات مربوط به ارتباط با بانک اطلاعاتی، در اين لايه ذخيره می شود.

لايه دوم، لايه Session است. در اين لايه، همه متغيرها در سرتاسر برنامه کاربردی يا تا برقرار بودن جلسه کاربر، در دسترس يک کاربر بخصوص هستند.

لايه سوم و آخر، لايه Page است. در اينجا همه متغيرهای تعريف شده در صفحه در سرتاسر آن صفحه در دسترس هستند. متغيرهای تعريف شده در يک صفحه ASP.NET از صفحه ديگر قابل دستيابی نيستند.

به علاوه در زمان استفاده از code-behindها در صفحات ASP.NET، در پيمانه های کلاس خود به متغيرهای سطح Procedure ،Private ،Public و Block دسترسی داريد. متغيرهای عمومی در کلاس هايی که در آنها ايجاد شده اند و نيز پيمانه های کلاس ديگر قابل دسترسی هستند. جلوی اين متغيرها کلمه کليدی Public قرار می گيرد. متغيرهای خصوصی تنها در دسترس توابع و روال های کلاس هايی هستند که در آنها تعريف شده اند.

قبل از متغيرهای خصوصی کلمه کليدی Private قرار می گيرد. متغيرهای سطح Block تنها در بلوک های برنامه ايجاد کننده خود در دسترس می باشند. قبل از متغيرهای سطح Procedure و Block کلمه کليدی Dim قرار می گيرد.

نکته حائز اهميت اين است که بايد به خاطر بسپاريم که هميشه بايد نوع داده های متغير خود را تعريف کنيم. در زير ليستی از انواع داده های پشتيبانی شده در VB.NET آورده شده است.

Boolean: درست يا نادرست
Byte: برای داده های عددی 0 تا 255
Char: برای يک کاراکتر يونيکد
Date: اطلاعات تاريخ و زمان
Decimal: اطلاعات عددی صحيح
Double: داده های عددی اعشاری
Integer, Long, Short, Single: داده های عددی صحيح
Object: متغير حامل پيش فرض جهت نگهداری هر نوع شئ
String: رشته های حرفي

در نگارشهای قبلی ويژوال بيسيک و در VBScript همه متغيرها بطور پيش فرض از نوع داده variant بودند. Variant در VB.NET وجود ندارد و با نوع داده Object جايگزين شده است.

(برگرفته از کتاب آموزشی ASP.NET از انتشارات کانون نشر علوم)

همه مقالات آشنايی با VB.NET را ببينيد.
جستجو: بگرد!
جستجوی پيشرفته
نام کاربری |
کلمه عبور |


IranASP.NET - مقدمه ای بر ASP

مقدمه ای بر ASP

مديريت سايت | اين مقاله ۷۱۰۹ بار تاکنون ديده شده است.
۱۳۸۰/۸/۲ | برای وبلاگ برای وبلاگ
نقطه شروع کار با ASP شامل معرفی، کاربرد و مزايای ASP

Active Server Pages فناوری شرکت ميکروسافت جهت توليد سايتهای پويای وب می باشد. بعبارت ديگر ASP يک روش توليد صفحات وب است که طراحان وب را قادر می سازد تا صفحات HTML را بگونه ای طراحی نمايند که اين صفحات برحسب مورد و در زمان فراخوانی بصورت خودکار ايجاد شوند. بسياری از سايتهای وب بزرگ و معروف از اين فناوری استفاده نموده اند، مانند:

• www.microsoft.com - Microsoft
• www.dell.com - Dell online
• www.bn.com - Barnes & Noble

در ASP دستورالعمل ها (Script) بر روی سرور اجرا می شوند و سپس حاصل آن بصورت HTML به کامپيوتر کاربر ارسال می گردد. VBScript زبان پيش فرض دستورالعمل نويسی است، اما شما می توانيد از ديگر زبانهای دستورالعمل نويسی مانند JScript ، Perl استفاده کنيد.يک صفحه ASP مانند يک صفحه HTML است با اين تفاوت که پسوند نام فايل آن "asp." می باشد. همچنين يک صفحه ASP می تواند دستورالعملهای نزد سرور و نزد کاربر را همزمان درون خود داشته باشد. بعبارت ديگر در ASP معمولا از VBScript برای دستورالعملهای نزد سرور و از JavaScript برای دستورالعملهای نزد کاربر استفاده می گردد. دقت داشته باشيد که JScript و JavaScript دو زبان متفاوت هستند.

قابليت های ASP

• استقلال از مرورگر
ASP از مرورگر کاملا مستقل است زيرا تمامی دستورالعملها بر روی سرور اجرا می گردند و مرورگر تنها صفحات HTML معمولی را بعنوان حاصل اجرای دستورالعملها دريافت می کند.

• استفاده از زبان دستورالعمل نويسی
اين بدين معنی است که يک برنامه ASP براحتی قابل تغيير است چرا که زبانهای دستورالعمل نويسی نياز به کامپايل نداشته و براحتی می توان در يک ويرايشگر مانند Notepad برنامه نوشت و يا آن را تغيير داد.

• دسترسی آسان و سريع به انواع بانکهای اطلاعاتی
اعمال پيچيده مربوط به پردازش بانکهای اطلاعاتی در ASP بسيار ساده است به سرعت می توان برنامه دلخواه را نوشته يا تغيير داد. همان روش مورد استفاده در Visual Basic يا Visual C++ را می توانيد در ASP هم استفاده کنيد (ADO) و نياز به يادگيری مجدد روش خاصی نداريد.

بستر مورد نياز ASP (نزد سرور)

• Windows 2000: شامل ASP 3.0 و IIS 5.0
• Windows NT: شامل ASP 2.0 و IIS 4.0
• Windows 95/98: می توان با نصب Personal Web Server (PWS) از ASP 2.0 استفاده نمود.
• ساير سيستم عامل ها: می توان با استفاده از نرم افزار Chilisoft - www.chilisoft.com تقريبا در هر سيستم عاملی از ASP استفاده نمود.

همه مقالات ASP کلاسيک را ببينيد.
جستجو: بگرد!
جستجوی پيشرفته
نام کاربری |
کلمه عبور |


IranASP.NET - ASP چگونه کار می کند؟

ASP چگونه کار می کند؟

مديريت سايت | اين مقاله ۷۸۷۳ بار تاکنون ديده شده است.
۱۳۸۰/۸/۳ | برای وبلاگ برای وبلاگ دريافت کد
آشنائی با روش کار صفحات ASP و مقايسه آن با HTML به همراه مثال

بهترين راه درک روش کار ASP مقايسه آن با يک صفحه HTML است. تصور کنيد که شما می خواهيد يک صفحه HTML واقع در آدرس http://www.somewhere.com/page.html را ببينيد. مراحل زير را خواهيم داشت:
۱- ابتدا آدرس فوق را در محل آدرس مرورگرتان وارد می کنيد.
۲- مرورگرتان درخواست شما را به وب سرور مربوطه می فرستد.
۳- وب سرور صفحه مورد نظر را از ديسک سخت (يا حافظه) خود خوانده و آن را به مرورگر شما می فرستد.
۴- مرورگر صفحه دريافتی را نمايش می دهد.

همانگونه که مشاهده کرديد مراحل فوق اعمال ساده ای هستند و پردازش خاصی صورت نمی گيرد. حال فرض کنيد می خواهيد يک صفحه ASP به آدرس http://www.somewhere.com/page.asp را ببينيد:
۱- ابتدا آدرس فوق را در محل آدرس مرورگرتان وارد می کنيد.
۲- مرورگرتان درخواست شما را به وب سرور مربوطه می فرستد.
۳- وب سرور صفحه مورد نظر را از ديسک سخت (يا حافظه) خود می خواند.
۴- صفحه يافت شده توسط وب سرور از ابتدا تا انتها پردازش شده و هر دستورالعملی که در صفحه يافت شود اجرا می گردد و معادل آن کد HTML توليد شده و به سوی مرورگر شما ارسال می گردد.
۵- مرورگر صفحه دريافتی را نمايش می دهد.

مرحله اضافی در اينجا نسبت به حالت قبل مرحله شماره ۴ می باشد و تفاوت اساسی ميان صفحات ASP و HTML را بيان می کند. لازم به ذکر است که پردازشگر صفحات ASP در وب سرور فايل يا برنامه ASP.dll در می باشد و کليه دستورالعملهای ASP بين دو علامت <% و %> قرار می گيرند.
جهت درک بهتر مطالب فوق به مثال ساده زير توجه نمائيد:

<%For I = 1 To 5%>
<Font Size="<%=I>">Hello World </Font><br>
<%Next%>

همه مقالات ASP کلاسيک را ببينيد.
جستجو: بگرد!
جستجوی پيشرفته
نام کاربری |
کلمه عبور |


IranASP.NET - يک صفحه ASP.NET ساده

يک صفحه ASP.NET ساده

مديريت سايت | اين مقاله ۶۱۷۷ بار تاکنون ديده شده است.
۱۳۸۰/۸/۳ | برای وبلاگ برای وبلاگ
اولين برنامه در ASP.NET و شرح قسمتهای آن

يک صفحه ASP.NET بطور عمده دارای دو بخش است: قسمت تعريف کد و قسمت اجرا. قسمت تعريف کد شامل تعريف کليه موارد و زيربرنامه هايی است که در قسمت اجرای کد استفاده می شوند. قسمت اجرای کد بخشی از صفحه است که در هنگام فراخوانی صفحه اجرا می شود و حاصل آن کد HTML است که به مرورگر ارسال می گردد.

بعنوان مثال در زير يک صفحه ASP.NET ساده آمده است که حاصل اجرای آن نمايش زمان جاری است. اين صفحه به ويژوال بيسيک نوشته شده است.

<Script Runat="Server">
Sub Page_Load
myLabel.Text = DateTime.Now()
End Sub
</Script>
<html>
<head><title>Simple.aspx</title></head>
<body>
<asp:Label
ID="myLabel"
Runat="Server" />
</body>
</html>

قسمت تعريف کد
قسمت تعريف کد در ليست ۱ آن قسمت از صفحه است که با برچسب <Script Runat="Server"> شروع شده و با برچسب <Script/> تمام می شود. در ليست بالا يک زيربرنامه بنام Page-Load تعريف شده است که در هنگام فراخوانی صفحه، بطور خودکار اجرا می شود. اين زيربرنامه صفت Text مربوط به ابزار Label را با زمان و تاريخ جاری مقداردهی می کند.

قسمت اجرای کد
قسمت اجرای کد در اين صفحه عبارت است از مابقی صفحه در زير قسمت تعريف کد. شما حتما تاکنون متوجه شده ايد که عمده قسمت اجرای کد می تواند همان HTML معمولی باشد. در اين قسمت از ابزار Label از مجموعه ابزارهای ASP.NET برای نمايش يک متن يا برچسب بروی صفحه HTML استفاده شده است. نحوه تعريف ابزار Label در زير آمده است:

<asp:Label ID="myLabel" Runat="Server"/>

هنگامی که اين صفحه اجرا می شود اين ابزار هم به کد متناظر HTML تبديل می شود.

همه مقالات کليات ASP.NET را ببينيد.
جستجو: بگرد!
جستجوی پيشرفته
نام کاربری |
کلمه عبور |


IranASP.NET - معرفی اوليه تكنولوژی ASP

معرفی اوليه تكنولوژی ASP

محمد جواد سخائی | اين مقاله ۶۰۳۶ بار تاکنون ديده شده است.
۱۳۸۰/۸/۸ | برای وبلاگ برای وبلاگ
معرفی فناوری ASP و تاريخچه آن بهمراه قابليت و لوازم شروع آن

شركت ماكروسافت در سال 1996 تكنولوژی ASP (Active Server Page) را معرفی نمود.تكنولوژی فوق اولين بار بهمراه سرويس دهنده اطلاعاتی اينترنت ( IIS :Internet Information Server ) نسخه 3.0 ارائه گرديد. با بكارگيری تكنولوژی فوق امكان طراحی و پياده سازی نرم افزارهای بزرگ و بانك های اطلاعاتی بهمراه صفحات وب فراهم می شود. هسته اوليه ASP , زبان Vbscript است . صفحات ASP بكمك كدهای نوشته شده توسط زبان فوق ايجاد می گردنند. Vbscript بعنوان زبان استاندارد برای پياده سازی صفحات ASP در نظر گرفته شده است ولی می توان از زبانهای Perl و Jscript در اين راستا نيز استفا ده نمود. ASP بر روی سرويس دهنده اجراء می گردنند. بديهی است در اين حالت عملكرد صفحات وب مستقل از توانائی های مرورگرها خواهد بود.

بنا به اظهارات شركت ماكروسافت در ماه مه سال 2000 , قريب به 800,000 هزار نفر در اين زمينه فعاليت داشته و به طراحی صفحات وب با بهره گيری از تكنولوژی فوق مشغول هستند. آمار فوق نشاندهنده رشد سريع و تصاعدی و استقبال عموم از تكنولوژی فوق در سطح جهان دارد. قريب به 500 شركت كامپيوتری در سطح جهان بصورت كاملا" تخصصی صرفا" به توليد قطعات و اجزای متفاوت بصورت كيت های آماده نرم افزاری بكمك ASP فعاليت داشته و محصولات ارائه شده توسط آنان بر روی استفاده در وب سايت های متعدد عرضه ميگردد.

ASP چه كارهائی را می تواند انجام دهد؟
تقريبا" همه چيز ! . توانائی های تكنولوژی فوق نامحدود است . مثلا" : دستيابی و جتسجو در بانك های اطلاعاتی متفاوت مستقل از بانك , شخصی نمودن صفحات وب , نمايش صفحات متفاوت برای مرورگرهای متفاوت , حفاظت رمز عبور , بازيهای كامپيوتری , پردازش فرم ها و نمونه هائی از توانائی های بيشمار تكنولوژی فوق می باشند.

برای شروع به چه چيزی نياز است ؟
جهت استفاده كامل از توانائی های ASP , می بايست سيستم عامل ويندوز NT 4.0 را بهمراه IIS 4.0 استفاده نمود( نسخه IIS 4.0 در زمان نصب ويندوز NT و پس از نصب NT 4.0 Option Pack ) بر روی سيستم نصب ميگردد. از ويندوز 2000 Server بهمراه IIS 5.0 نيز ميتوان در اين زمينه استفاده نمود.

جهت استفاده از ASP بر روی كامپيوترهائی كه بر روی آنها ويندوز 98 و يا 95 نصب گرديده است ميتوان سرويس دهنده شخصی وب ( PWS: Personal Web Server ) را بر روی كامپيوتر نصب نمود . جهت نصب PWS , كافيست از CD ويندوز 98 استفاده و در شاخه Add-ons\PWS برنامه Setup را اجراء نمود.

همه مقالات ASP کلاسيک را ببينيد.
جستجو: بگرد!
جستجوی پيشرفته
نام کاربری |
کلمه عبور |


IranASP.NET - ويژگی های تكنولوژی ASP

ويژگی های تكنولوژی ASP

محمد جواد سخائی | اين مقاله ۴۷۳۰ بار تاکنون ديده شده است.
۱۳۸۰/۸/۸ | برای وبلاگ برای وبلاگ
معرفی ويژگی ها و قابليت های تكنولوژی ASP

معرفی برخی ويژگی های تكنولوژی ASP
• ASP، يك محيط مناسب بر روی سرويس دهنده را بگونه أی فراهم می كند كه امكان ايجاد صفحات وب پويا و نرم افزارهای كاربردی تحت وب بسرعت و بسادگی فراهم ميگردد .

• صفحات ASP ، فايل هائی هستند كه شامل دستورات ( تگ ها ) HTML ، متن و دستورات اسكريپت می باشند.

• صفحات ASP می توانند اجزای ActiveX را جهت انجام عمليات خاصی نظير اتصال به يك بانك اطلاعاتی و يا محاسبات تجاری خاصی و انجام دهند.

• با استفاده از تكنولوژی ASP ، ميتوان اقدام به طراحی و پياده سازی صفحات وب پويا نمود.

• با استفاده از تكنولوژی ASP ، ميتوان اطلاعات متفاوتی را از طريق فرمهای موجود در صفحات وب جمع آوری و پردازش دلخواه را بر روی آنها انجام داد.

• جهت ايجاد صفحات ASP ، می توان از زبانهای اسكريپت متعددی نظير : Vbscript، Jscript، Perl، Rexx و استفاده نمود.

مدل عملياتی ASP
دستورات و اسكريپت های موجود در صفحات ASP ، زمانی اجراء ميگردنند كه مرورگر يك فايل با انشعاب .asp ، را از سرويس دهنده وب تقاضا نمايد. در ادامه سرويس دهنده وب ، ASP مربوطه را صدا زده و پس از اجرای دستورات و اسكريپت های موجود در آن ، ماحصل نتايج بصورت يك صفحه وب برای مرورگر ارسال ميگردد .

با توجه به اينكه صفحات ASP بر روی سرويس دهنده اجراء می گردنند، بنابراين تمامی عمليات مربوط به اجرای اسكريپت ها و دستورات بر روی سرويس دهنده انجام شده و وابسته به مرورگر نخواهد بود. در ضمن با توجه به اجرای صفحات ASP بر روی سرويس دهنده ، امكان مشاهده و تكثير اين نوع فايل ها وجود نداشته و صرفا" ماحصل ( نتايج ) اجرای ASP بصورت كدهای استاندارد HTML برای مرورگر ارسال ميگردد.

همه مقالات ASP کلاسيک را ببينيد.
جستجو: بگرد!
جستجوی پيشرفته
نام کاربری |
کلمه عبور |


IranASP.NET - انواع داده ای در Visual Basic.NET

انواع داده ای در Visual Basic.NET

مديريت سايت | اين مقاله ۶۰۶۳ بار تاکنون ديده شده است.
۱۳۸۰/۸/۱۳ | برای وبلاگ برای وبلاگ
چگونگی تعريف متغير و انواع داده ای در ويژوال بيسيک دات نت

برای تعريف يک متغير در ويژوال بيسيک دات نت از عبارت Dim استفاده می شود. برای مثال چمله زير يک متغير جديد به نام myVar تعريف می کند:

Dim myVar

هنگامی که يک متغير مانند فوق بدون در نظر گرفتن نوع آن تعريف شود، آن متغير بعنوان يک شئ (Object) در نظر گرفته می شود. يک متغير از نوع شئ در دات نت می تواند شامل انواع داده از قبيل رشته، عدد يا انواع پيچيده تر مانند کلاس باشد.

اغلب نيازی نيست که از متغيرهای از نوع شئ در برنامه استفاده شود چرا که اين متغيرها باعث کاهش کارآيی و سرعت برنامه می شود. هنگامی که از يک متغير از نوع شئ استفاده شود، نوع مناسب آن متغير در زمان اجرا تشخيص داده می شود و اين باعث کندی می شود. بنابراين بهتر است که نوع داده را از ابتدا مشخص کنيم.

جهت مشخص نمودن نوع داده از کلمه کليدی As استفاده می کنيم. بعنوان مثال يک متغير از نوع رشته بصورت زير تعريف می شود:

Dim myVar As String

مجموعه دات نت انواع داده ای زير را پشتيبانی می کند:

• Boolean: جهت مقادير درست يا نادرست
• Byte: جهت مقادير صحيح صفر تا ۲۵۵ (تنها مقادير مثبت)
• Char: جهت مقادير نويسه ها يا حروف يونيکد
• Date: جهت مقادير تاريخ و زمان بين اول ژانويه ۰۰۰۱ و ۳۱ دسامبر ۹۹۹۹
• Decimal: جهت مقادير صحيح بين صفر و مثبت و منفی ۷۹,۲۲۸,۱۶۲,۵۱۴,۲۶۴,۳۳۷,۵۹۳,۵۴۳,۹۵۰,۳۳۵ (۱۶ بايت)
• Double: جهت مقادير اعشاری با دقت مضاعف
• Integre: جهت مقادير صحيح بين +۲,۱۴۷,۴۸۳,۶۴۷ و -۲,۱۴۷,۴۸۳,۶۴۸ (۴ بايت)
• Long: جهت مقادير صحيح بين -۹,۲۲۳,۳۷۲,۰۳۶,۸۵۴,۷۷۵,۸۰۸ و +۹,۲۲۳,۳۷۲,۰۳۶,۸۵۴,۷۷۵,۸۰۷ (۸ بايت)
• Short: جهت مقادير صحيح بين -۳۲,۷۶۸ و +۳۲,۷۶۷ (۲ بايت)
• Single: جهت مقادير اعشاری با دقت واحد
• String: جهت مقادير رشته ای با تعداد حروف صفر تا دو ميليارد حرف

پر کاربردترين انواع داده ای عبارتند از Integer، Decimal، Date، Boolean و String.

دقت کنيد که نوع داده ای Currency يا Money برای مقادير پولی در نظر گرفته نشده است و شما می توانيد برای مقادير پولی از نوع Decimal استفاده کنيد.

همه مقالات آشنايی با VB.NET را ببينيد.
جستجو: بگرد!
جستجوی پيشرفته
نام کاربری |
کلمه عبور |


IranASP.NET - درس دوم: بررسی ساختار و دستور زبان ASP

درس دوم: بررسی ساختار و دستور زبان ASP

محمد جواد سخائی | اين مقاله ۶۰۶۰ بار تاکنون ديده شده است.
۱۳۸۰/۸/۱۷ | برای وبلاگ برای وبلاگ دريافت کد
آشنائی با ساختار برنامه در ASP بهمراه چند مثال

كدهای نوشته شده در يك ASP را نمی توان در يك مرورگر مشاهده نمود. در چنين حالتی صرفا ماحصل اجرای كدهای ASP بصورت كدهای HTML توسط مرورگرها قابل نمايش خواهد بود.

قانون اوليه در رابطه با گرامر ASP
يك فايل ASP اغلب شامل كدهای HTML نظير آنچه كه در يك فايل HTML استاندارد قرار می گيرد، است. علاوه بر كدهای HTML كه در يك فايل ASP قرار می گيرد، می توان از مجموعه ای اسكريپت مخصوص سرويس دهنده نيز استفاده كرد . اين اسكريپت ها بين <% و %> قرار می گيرند. اسكريپت های استفاده شده بر روی سرويس دهنده اجراء شده و می تواند شامل عبارات، عملگرها، جملات، برنامه های فرعی و ساير امكانات مجاز مربوط به زبانهای اسكريپت باشد.

تمامی علاقه مندان به دنيای نرم افزار بخصوص برنامه نويسی بخوبی آگاه هستند كه در زمان آشنائی با يك زبان برنامه نويسی ، اولين برنامه ا ی كه نوشته می شود و يا روی آن بحث می گردد، برنامه Hello World معروف است . مهمترين ويژگی اين نوع از برنامه ها آشنائی سريع و اوليه علاقه مندان با ساختار يك زبان برنامه نويسی و شناخت امكانات خروجی زبان مورد مطالعه است . ما هم در اين زمينه برای معرفی ساختار يك برنامه ASP از چنين نقطه ای آغاز می كنيم . اما قبل از آن با ابزار اوليه در اين راستا می بايست بهتر آشنا شويم.

معرفی شئ Response
متد Write مربوط به شئ Response ، مسئول ارسال اطلاعات ( محتويات ) به مرورگر است. مثلا در صورتيكه بخواهيم عبارت معروف فوق، توسط مرورگر نمايش داده شود، كافی است از دستور Response.Write("Hello World") استفاده گردد.

در ASP از زبانهای اسكريپت متفاوتی استفاده می شود. زبان پيش فرض در اين زمينه VBScript است.

<%
Response.write("Hello World!")
%>

در صورتيكه بخواهيم از زبان جاو اسكريپت بعنوان زيان پيش فرض استفاده كنيم ،كافی است در ابتدای صفحه زبان فوق را معرفی نمائيم.

<%
Response.write('Hello World!');
%>

جاوا اسكريپت بر خلاف VBScript به حروف بزرگ و كوچك حساسيت داشته و می بايست اين امر مورد توجه قرار گيرد.

ASP امكان نوشتن كدهای مورد نظر را بكمك زبانهای اسكريپت جاوا اسكريپت و VBScript فراهم می كند. در صورتيكه قصد استفاده از ساير زبانهای اسكريپت نظير Perl , Python , را داشته باشيم، می بايست هسته ( engines ) مربوط به آن زبان بطور جداگانه نصب گردد. در پايان اين بخش به بررسی دو مثال ساده خواهيم پرداخت.

مثال در اين مثال با نحوه شکل دهی در يك ASP و بكمك امكانات موجود درHTML آشنا می شويم.

<%
Response.Write("<h2>Hello World!<br>This sentence uses HTML<br> tags to format the text!</h2>")
%>

همه مقالات ASP کلاسيک را ببينيد.
جستجو: بگرد!
جستجوی پيشرفته
نام کاربری |
کلمه عبور |


IranASP.NET - درس سوم: بررسی متغيرها در ASP

درس سوم: بررسی متغيرها در ASP

محمد جواد سخائی | اين مقاله ۵۵۸۰ بار تاکنون ديده شده است.
۱۳۸۰/۸/۱۷ | برای وبلاگ برای وبلاگ دريافت کد
نحوه تعريف متغير و بکارگيری آن در ASP

استفاده از متغير در يك برنامه بسيار حائز اهميت است. برنامه نويسان از متغيرها برای ذخيره سازی داده های مربوطه استفاده و زمينه پردازش داده های ذخيره شده با امكان دستيابی به متغيرها در طول يك برنامه فراهم می گردد. يك برنامه كامپيوتری خود می تواند شامل چندين برنامه جانبی بوده كه هر كدام مسئول انجام بخشی از عمليات در كل برنامه می باشند. متغيرها را می توان در درون يك تابع ( برنامه جانبی ) و هم بيرون از يك تابع تعريف نمود. نوع تعريف يك متغير ( محلی و يا سراسری ) محدوده مجاز دستيابی به متغير را تبين خواهد ساخت.

در برنامه های ASP، زمانيكه يك متغير در خارج از يك تابع تعريف می گردد، امكان دستيابی به آن در طول برنامه فراهم شده و از اين بابت محدوديت در دسترسی را نخواهد داشت. در صورتيكه يك متغير در يك تابع تعريف گردد، در زمان صدا زدن تابع متغير ايجاد و پس از خروج از تابع متغير از بين خواهد رفت. بديهی است در چنين حالتی اسكريپت های موجود در ساير بخش های يك برنامه ASP، قادر به دستيابی و تغيير محتويات اينچنين متغيرهائی نخواهند بود. تا كنون بحث ما مربوط به محدوده مجاز يك متغير در يك فايل ( برنامه ) ASP بود، در صورتيكه بخواهيم امكان دستيابی به يك متغير را در طول چندين فايل ASP فراهم كنيم، می بايست آن را بصورت يك متغير Session و يا يك متغير Application تعريف نمائيم.

متغيرهای Session
اين نوع متغيرها اطلاعاتی را در رابطه با يك كاربر ذخيره كرده و امكان دستيابی به آن برای تمامی صفحات موجود در يك برنامه فراهم می گردد. اغلب اطلاعات عمومی نظير نام كاربر و مشخصه آن در چنين متغيرهائی ذخيره می گردد. پس از ايجاد يك متغير Session، از شی Session برای ذخيره سازی آن استفاده می گردد.

متغيرهای Application
اين نوع متغيرها نيز قابل دستيابی در تمامی صفحات مربوط به يك برنامه ASP می باشند. از اين متغيرها اغلب جهت ذخيره سازی اطلاعات در رابطه با تمامی كاربران يك برنامه خاص، استفاده می گردد. پس از ايجاد متغيری از اين نوع، از شی Application برای ذخيره سازی آن استفاده می گردد.

در ادامه به بررسی چندين مثال كاربردی از نحوه تعريف و بكارگيری متغيرها در برنامه های ASP خواهيم پرداخت.

مثال ۱ - ايجاد يك متغير . در اين مثال با نحوه تعريف، مقداردهی و استفاده از يك متغير، آشنا خواهيم شد.

<%
Dim name
name="IranASP.NET"
Response.write("My favorite site is:"& name)
%>

مثال ۲ - ايجاد يك آرايه ( بردار ) . از ساختمان داده بردار برای ذخيره سازی مجموعه ای محدود و يكسان داده استفاده ميگردد. در اين مثال با نحوه تعريف و استفاده از يك بردار آشنا خواهيم شد.

<%
Dim myaim(4)
myaim(0) = "I"
myaim(1) = "Like"
myaim(2) = "To"
myaim(3) = "Learn"
myaim(4) = "ASP"
For i = 0 to 4
response.write(myaim(i) & "<br>")
Next
%>

مثال ۳ - حلقه تكرار . در اين مثال با نحوه بكارگيری متغيرها و استفاده از آنان در حلقه های تكرار آشنا خواهيم شد

<%
Dim i
for i = 1 to 6

response.write("<h" & i & ">This is header " & i & "")

Next
%>

مثال ۴ - در اين مثال با توجه به زمان مربوط به سرويس دهنده، پيامهای متفاوتی به كاربر داده خواهد شد.

<%
Dim h
h = hour(now)
response.write("<p>" & now)
response.write(" (Local Time) </p>")
If h < 12 then
response.write("Good Morning!")
else
response.write("Good Night!")
end if
%>

همه مقالات ASP کلاسيک را ببينيد.
جستجو: بگرد!
جستجوی پيشرفته
نام کاربری |
کلمه عبور |


IranASP.NET - معماری فايل ASP.NET

معماری فايل ASP.NET

مديريت سايت | اين مقاله ۵۰۴۵ بار تاکنون ديده شده است.
۱۳۸۱/۶/۲۶ | برای وبلاگ برای وبلاگ
آشنايی با انواع فايل و پسوندهای آنها در برنامه های کاربردی ASP.NET.

در عمل و ساختار برنامه های کاربردی ASP.NET از فايل های زيادی استفاده می شود. در ادامه فايل های تشکيل دهنده برنامه کاربردی ASP.NET را فهرست و نقش آنها در برنامه را خواهيم ديد.

asax.
اين پسوند برای فايل خاصی بنام Global.asax استفاده می گردد. اين نوع فايل محتوی ترکيب نحوی رويداد برای نوشتن رويدادهای سطح برنامه کاربردی ASP.NET است. آن را می توان در دايرکتوری ريشه يک برنامه کاربردی ASP.NET پيدا کرد.

ascx.
اين نوع فايل نمايانگر يک کنترل تعريف شده توسط برنامه نويس ASP.NET است (User Control). صفحات ASP.NET عموما از کنترلهای سرويس دهنده (کادرهای متنی، کادرهای فهرست، دکمه ها و غيره) تشکيل شده اند که عناصر اوليه صفحه وب را می سازند. ASP.NET درست مانند برنامه سازی مرسوم ويژوال بيسيک امکان ايجاد کنترلهای تعريف شده توسط برنامه نويس را فراهم می کند. اين کنترل ها معمولا از ترکيب کنترل های سرويس دهنده و برنامه سازی برای انجام يک وظيفه يا مجموعه ای از وظايف بخصوص تشکيل می شوند.

asmx.
اين پسوند برای سرويس های XML وب استفاده می گردد. اين نوع فايل از سوی آن دسته از سرويس های وب ميزبان مورد استفاه قرار می گيرد که از راه دور يا بطور محلی در معرض برنامه های کاربردی NET. هستند. سرويس وب موجوديتی قابل برنامه ريزی است که برای برنامه کاربردی يک عنصر خاص کارکرد معينی را تامين می کند.

aspx.
از اين پسوند که اصلی ترين پسوند ASP.NET است برای فرم های وب و صفحات معمولی ASP.NET استفاده می گردد.

axd.
اين نوع فايل مربوط به tracing برنامه کاربردی ASP.NET است و به ASP.NET اجازه می دهد تا به جمع آوری اطلاعات درباره درخواستهای HTTP برای يک برنامه کاربردی بپردازد.

vsdisco.
اين نوع فايل XML، لينک ها را در معرض منابع ديگری قرار می دهد که سرويس وب را توصيف می کنند. از فايل VSDISCO برای کشف سرويس های وب استفاده می شود که بطور عمومی موجود هستند.

htm.
فايل های معمولی از نوع HTML را در برمی گيرند.

xml.
اين نوع سند XML مخصوص استفاده در برنامه های کاربردی ASP.NET است. اين فايل XML برای مقاصد مختلفی استفاده می شود از جمله نگهداری اطلاعات برنامه کاربردی و نيز مجموعه داده های بازگشته از بانک اطلاعاتي.

vb.
اين فايل شامل کد ويژوال بيسيک است که آن نيز به نوبه خود به يک فايل ASPX يا ASCX به ارث می رسد و کليه عمليات برنامه ای مربوط به صفحات ASP.NET در آن قرار می گيرد. اين نوع فايل اصطلاحا code-behind نيز ناميده می شود.

cs.
همانند پسوند vb. است اما بجای کد ويژوال بيسيک حاوی کد زبان #C است.

config.
پسوند فايل web.config است.اين نوع فايل بر يک فايل پيکربندی دلالت دارد يعنی فايلی که از آن برای تعيين صفات مشخصه مختلف برنامه کاربردی استفاده می شود. اين صفات مشخصه شامل تنظِمات اشکال زدايي(debuging)، تائيد امنيت(authentication)، کارکرد پيگيری (tracing)، نگهداری جلسه کاری (state management) و عمومی سازی (globalization & localization) می شوند.

(برگرفته از کتاب آموزشی ASP.NET از انتشارات کانون نشر علوم)

همه مقالات کليات ASP.NET را ببينيد.
جستجو: بگرد!
جستجوی پيشرفته
نام کاربری |
کلمه عبور |


IranASP.NET - codebehind چيست؟

codebehind چيست؟

مديريت سايت | اين مقاله ۶۱۰۵ بار تاکنون ديده شده است.
۱۳۸۱/۷/۲ | برای وبلاگ برای وبلاگ
بررسی مفهوم codebehind و مزايا و نحوه بکارگيری و پياده سازی آن به سه روش مختلف

codebehind اصطلاحی است که به مجموعه کدهای برنامه ای که يک فرم وب (يا سرويس وب يا کنترل کاربری يا ديگر اشياء ASP.NET) استفاده می کند می گويند. اين کدها درون فايل ASPX (يا ASMX يا ASCX) نبوده بلکه درون فايل ديگری با پسوند aspx.cs-برای #C (برای VB.NET بصورت aspx.vb) قرار می گيرند. جداسازی کد برنامه از عبارات HTML در يک فرم وب دارای محاسن و مزيتهای بسيار زيادی است. برخی از اين مزيتها عبارتند از:
• امکان جداسازی تيمهای توليد يک سايت وب بدين صورت که طراحان صفحات می توانند بدون آنکه کاری به کدهای برنامه صفحه داشته باشند يا آسيبی به آن برسانند با عبارات HTML مربوطه کار کنند.
• حفاظت و امنيت برنامه
• پشتيبانی بسيار خوب محيط VS.NET (ويژوال استوديو دات نت) از اين مفهوم
• سرعت توليد سايتهای وب
• نگهداری آسان سايتها و برنامه های ايجاد شده

VS.NET تقريبا هيچگونه امکاناتی را جهت استفاده از بلوکهای <Script runar="server"> که مفهوم مقابل codebehind است را ندارد.

حال که با مزايای codebehind آشنا شديم، سوال بعدی اين است که اين مفهوم چگونه کار می کند؟ در ASP.NET همه چيز شئ يا object می باشد. در ASP.NET حتی يک صفحه ASPX بدون هرگونه کد و برنامه هم يک شئ می باشد که از کلاس System.Web.UI.Page به ارث گرفته شده است. هنگامی که صفحه مذکور برای اولين بار فراخوانی (اجرا) می شود محتويات آن صفحه توسط هسته ASP.NET کامپايل شده و نسخه کامپايل شده آن تا زمانی که تغييری در صفحه ايجاد نشده است، جهت فراخوانی های بعدی در سيستم cache می شود.

از آنجا که يک صفحه ASPX بصورت شئ عمل می کند لذا ما می توانيم بخوبی از مفهوم وراثت در برنامه نويسی شئ گرا بهره ببريم. بدين صورت که می توانيم کلاس پدر آن را بطور دلخواه تعريف و پياده سازی کنيم بشرطی که اين کلاس پدر خود بنوعی از کلاس System.Web.UI.Page به ارث گرفته شده باشد.

کلاس codebehind
بجای اينکه صفحه ASPX شما مستقيما از کلاس System.Web.UI.Page به ارث گرفته شود، صفحه شما می تواند از يک کلاس دلخواه ديگر بصورت زير به ارث گرفته شود:

<%@ Page Inherits="YourNamespace.NewPage" %>

بمنظور عمل نمودن عبارت فوق، کلاس NewPage بايد بصورت مستقيم يا غير مستقيم از کلاس System.Web.UI.Page به ارث گرفته شده باشد. هنگام فراخوانی صفحه فوق، هسته ASP.NET در شاخه bin\ يا اسمبلی سراسری cache شده (Global Assembly Cache) بدنبال کلاس NewPage می گردد و در صورتيکه آن را پيدا نکند خطائی را اعلام می کند. با استفاده از اين روش می توان يک کلاس پايه بدين منظور در سراسر يک برنامه يا سايت وب داشت بطوريکه همه صفحات از آن کلاس به ارث گرفته شوند. بعنوان مثال مجله الکترونيکی angryCoder از همين روش استفاده کرده است. بهرحال بيشتر برنامه ها از کلاس های متفاوتی جهت کلاس codebehind صفحات خود استفاده می کنند.

شما می توانيد فايلی را که محتوی codebehind شماست را به هسته ASP.NET معرفی کنيد. اين معرفی سبب می شود که ASP.NET خود بقيه کارهای لازم (کامپايل کردن فايل codebehind و قرار دادن حاصل آن که در اصل يک فايل dll است در شاخه bin\ برنامه) را انجام دهد. اين کار را با استفاده از مشخصه Src بصورت زير می توانيد انجام دهيد:

<%@ Page Src="NewPage.aspx.cs" Inherits="YourNamespace.NewPage" %>

اگر از VS.NET استفاده می کنيد بصورت پيش فرض مقدمات استفاده از codebehind برای شما بصورت زير فراهم شده است:

<%@ Page Codebehind="NewPage.aspx.cs" Inherits="YourNamespace.NewPage" %>

VS.NET کليه فايلهای codebehind را در قالب يک فايل dll يا اسمبلی کامپايل کرده و حاصل را در شاخه bin\ موجود در شاخه اصلی برنامه يا سايت قرار می دهد. دقت داشته باشيد که الويت مشخصه Src از مشخصه Codebehind بالاتر است و در صورت استفاده همزمان از آنها در دايرکتيو Page، فايل معرفی شده در عبارت Src بعنوان فايل codebehind در نظر گرفته می شود.

خلاصه
با توجه به مطالب فوق، سه روش جهت معرفی codebehind وجود دارد. روش اول بدين صورت است که با فرض موجود بودن dll مربوطه در شاخه bin\، تنها به ذکر نام کلاس codebehind در عبارت Inherits اکتفا نمائيم. روش دوم استفاده از مشخصه Src جهت معرفی نام فايل codebehind است. اين روش سبب می شود تا ASP.NET با استفاده از کامپايلر JIT محتوای فايل codebehind را قابل استفاده نمايد. روش سوم که روش VS.NET است از مشخصه Codebehind استفاده می کند. اين روش همانند روش اول است با اين تفاوت که خود VS.NET کليه کارهای لازم را بصورت خودکار برای ما انجام می دهد.

همه مقالات کليات ASP.NET را ببينيد.
جستجو: بگرد!
جستجوی پيشرفته
نام کاربری |
کلمه عبور |


IranASP.NET - ASP.NET و پايگاه داده - قسمت دوم

ASP.NET و پايگاه داده - قسمت دوم

شاهو طوفانی | اين مقاله ۹۵۹۸ بار تاکنون ديده شده است.
۱۳۸۱/۷/۸ | برای وبلاگ برای وبلاگ دريافت کد
اين مقاله به بررسی استفاده از شئ DataSet و بکارگيری شئ DataAdapter در واکشی اطلاعات از يک پايگاه داده می پردازد.

قسمت اول

در اين بخش شما به دانسته های بخش اول نياز داريد. شئ بعدی که مورد بحث قرار می گيرد کلاس Data Adapter است. OleDBDataAdapter اطلاعات را می گيرد و يک ارتباط منطقی بين داده ها و کلاس Dataset ايجاد ميکند. بطور کلی ميتوان گفت Data Adapter در نظر اول معادل Data Command می باشد. روش استفاده از Data Adapter ها بطور معمول بصورت زير تعريف می شود:

Dim objAdapter As New OleDBDataAdapter("Select * From Users",objConn)

ملاحظه می کنيد که شئ Adapter از دو پارامتر- يکی رشته دستورات SQL و ديگری رشته ارتباطی - برای فرستادن دستورات به پايگاه داده استفاده می کند. بطور معمول DataAdapter برای پرکردن DataSetها و بروز کردن پايگاه بوسيله يک DataSet و اجرا کردن دستورات بکار می رود. اکنون نمای کلی از کاربرد فوق را در زير می بينيد:

Dim ds As DataSet = New DataSet()
objAdapter.Fill(ds,"Users")

متد Fill جهت اجرای دستور تنظيم شده در Data Adapter بکار می رود. بعبارت ديگر اطلاعات واکشی شده از پايگاه داده در يک جدول با نامی که ما تعيين می کنيم (Users) ذخيره می شود.
نکته ضروری اينست که تکنيک Mappings در اکثر مواقع کارساز است. Mappings عبارت است از ساختن يک نام مستعار (Alias) برای نام جداول در يک Dataset. اين aliasها هيچگونه تاثيری در منبع داده ندارد و وقتی که بوسيله DataAdapter فرستاده می شود بصورت خودکار بنام پيش فرض تبديل ميشود. اين تکنيک باعث خوانايی کد و راهنمايی برنامه نويس در ارجاع های بعدی وتشخيص جداول فراخوانی شده ميشود.

objAdapter.TableMappings.Add("adbtable","Users")
with objAdapter.tableMapping(0).ColumnMappings
.Add("PID","ID")
.Add("LAstName","Lname")
.Add("StreetAddress","Addy")
End with
objAdapter.Fill(ds)

در تکنيک فوق بجای استفاده از عبارت ds.Tables("adbtable") ميتوانيم Ds.Tables("Users") را بکار ببريم. در بخشهای آينده ديگر فوايد استفاده از Mappings آمده است. همچنين کلاس CommandBuilder برای بهنگام کردن يک بانک که بوسيله Dataset صورت گرفته يک شيوه صحيح بشمار ميرود:

Dim cmdBLD As New OleDBCommandBuilder(objAdapter)

که در عبارت فوق شئ objAdapter بعنوان پارامتر به دستور CommandBuilder فرستاده شده و سپس بوسيله متد Update منبع داده بهنگام می شود:

objAdapter.Update(ds,"Users")

در ادامه، مثال زير بعنوان جمع بندی مطالب قبلی آمده است. توجه داشته باشيد در مثال زير نتيجه ای بعنوان خروجی در مرورگر نمايش داده نمی شود و فقط از منبع داده ای اطلاعات خوانده شده و يک شئ Dataset پر می شود:

<%@ Import NameSpace="System.data" %>
<%@ Import NameSpace="System.Data.OleDB" %>

<Script Language="VB" Runat="Server">

Sub Page_Load( Sender As Object, E As EventArgs)
Dim objConn As New OleDBConnection("PROVIDER=Microsoft.Jet.OLEDB.4.0;DATA Source=e:\db\users.mdb")

objConn.Open()
Dim ds As DataSet=New DataSet
Dim objAdapter As New OleDBDataAdapter("Select * From Users",objConn)
Dim objcmdBLD As New OleDBCommandBuilder(objAdapter)
Obj.Adapter.Fill(ds,"Users")
End Sub

</Script>

همه مقالات ADO.NET و پايگاه داده را ببينيد.
جستجو: بگرد!
جستجوی پيشرفته
نام کاربری |
کلمه عبور |


IranASP.NET - upload کردن فايل به سرور در ASP.NET

upload کردن فايل به سرور در ASP.NET

محمود مروج | اين مقاله ۶۹۳۵ بار تاکنون ديده شده است.
۱۳۸۱/۷/۲۹ | برای وبلاگ برای وبلاگ
اين مقاله به چگونگی upload کردن فايل به سرور در ASP.NET می پردازد.

کدهای مربوط به Upload کردن فايل به سرور را بايد به دو قسمت تقسيم نمود. قسمت اول شامل کدهايی است که نحوه نمايش در مرورگر را شامل می شوند و اساس آن بر HTML است. و قسمت دوم مربوط به طرف سرور است که شامل کدهايی است که با ASP.NET نوشته می شوند. برنامه زير حاوی کدهای مربوطه برای انجام اين کار به صورات خيلی ساده و ابتدايی می باشد. همانطور که ملاحظه می کنيد برخلاف ASP کلاسيک، نياز به وجود component خاصی نمی باشد و اين کار در ASP.NET بصورت خيلی ساده انجام پذير است.

Upload.aspx:
<HTML>
<HEAD>
<TITLE>Uploading File...</TITLE>
<Script language="vb" runat="server">
sub page_load(s as object,e as EventArgs)
If Not (MyInputFile.PostedFile Is Nothing) Then
MyInputFile.PostedFile.SaveAs("c:\filename.ext")
Response.write("Your File was saved on the server...")
End If
end sub
</script>
</HEAD>
<BODY>
<FORM method="post" encType="multipart/form-data">
<input id="MyInputFile" type="file" name="MyInputFile" runat="server">
<input type="submit" value="Submit">
</FORM>
</BODY>
</HTML>

در زير به شرح و توضيح برنامه بالا می پردازيم:

کدهای مربوط به طرف Client
به دليل آنکه در اين قسمت، ارسال اطلاعات به سرور را داريم، بايد کدهای مربوطه درون يک فرم قرار گيرند. اما لازم است که ويژگی encType آن فرم را به صورت زير مقدار دهی کنيم، زيرا در غير اينصورت فايل انتخاب شده توسط کاربر به سرور ارسال نخواهد شد:

encType="multipart/form-data"

در HTML کنترلی وجود دارد که وظيفه دريافت نام فايل و ارسال آن به سرور را عهده دار می باشد:

<input id="MyInputFile" type="file" name="MyInputFile" runat="server">

توجه کنيد که اين کنترل را به صورت يک سرور کنترل در می آوريم تا بتوانيم در ASP.NET از توانايی های آن استفاده نماييم و به همين دليل ويژگی runat="server" را به کنترل مربوطه اضافه کرده ايم. بنابراين کد مربوط به قسمت Client به صورت زير خواهد بود:

<body>
<form method="post" encType="multipart/form-data">
<INPUT id="MyInputFile" type="file" name="MyInputFile" runat="server">
<input type="submit" value="Submit">
</form>
</body>

کدهای مربوط به طرف Server
اين قسمت کدهايی را شامل می شود که برای ذخيره کردن فايل بر روی سرويس دهنده مورد استفاده قرار می گيرند.همانطور که گفته شد شئ مربوط به دريافت نام فايل را به صورت سرور کنترل قرار داديم تا بتوانيم از خصوصيات آن در سرور استفاده کنيم (در اينجا نام آنرا MyInputFile درنظر گرفته ايم). يکی از خصوصيات اين شئ، شئ PostedFile می باشد که به فايل ارسالی توسط کاربر اشاره می کند. اين شئ نيز شامل متدی است که اقدام به ذخيره فايل می کند. بنابراين قبل از ذخيره کردن بايد مطمئن شد که آيا شئ PostedFile به چيزی اشاره می کند و يا اينکه تهی است. برای اين منظور کد مربوط به ذخيره سازی را در شرط زير قرار می دهيم:

If Not (MyInputFile.PostedFile Is Nothing) Then

و درصورت صحيح بودن شرط، اقدام به ذخيره سازی می نماييم. متد SaveAs شئ PostedFile دارای پارامتری است که محل و نام فايلی که قرار است بر روی سرور ذخيره شود را مشخص می کند. در انتها نيز پيغامی مبنی بر اينکه فايل با موقيت ذخيره شده است را به کاربر می دهيم.

Response.write("Your File was saved on the server successfuly...")

بنابراين کد طرف سرور به صورت زير خواهد بود:

<script language="vb" runat="server">
sub page_load(s as object,e as EventArgs)
If Not (MyInputFile.PostedFile Is Nothing) Then
MyInputFile.PostedFile.SaveAs("c:\filename.ext")
Response.write("Your File was saved on the server...")
End If
end sub
</script>

چند نکته
ديگر خصوصيات شئ PostedFile به صورت زير است:
• ContentLength: به اندازه فايل ارسالی اشاره ميکند.
• ContentType: MIME فايل ارسالی را مشخص می کند که در تشخيص نوع فايل دريافتی کمک می کند.
(بعضی از انواع رايج MIME عبارت اند از : text/plain ، image/gif ، image/jpeg ، audio/mpeg ، application/msword ، application/octed-stream ، video/mpeg ، audio/wav و...)
• FileName: نام فايل و مسير آن در کامپيوتر شخص کاربر را معين می کند.(مانند C:\images\personal\myface.jpg)
• InputStream: يک شئ stream که به فايل upload شده اشاره می کند و آنرا برای خواندن محتوايش آماده می سازد.

يک نکته مهم
توجه کنيد که به طور پيش فرض طول داده های ارسالی در يک request حداکثر 4096 بايت (يا همان 4 kb ) می باشد. بدين معنی که يک فايل ارسالی حداکثر می تواند 4 kb باشد. برای اينکه اين مقدار را به مقدار لازم و مورد نياز افزايش دهيد بايد در فايل web.config ويا machine.config در قسمت <system.web> در صورتيکه قسمت زير موجود نيست آنرا اضافه کنيد

<httpRuntime maxRequestLength="1000000"/>

ودر صورت وجود مقدار maxRequestLength را به مقدار دلخواه تنظيم کنيد. اين مقدار بر حسب بايت می باشد. در مثال بالا مقدار ماکزيمم فايل ارسال يک ميليون بايت (حدود 1 MGB) می باشد. به عنوان نمونه يک فايل web.config که فقط نياز فوق را برآورده سازد به صورت زير خواهد بود:

Configuration file : web.config
<?xml version="1.0" encoding="utf-8" ?>
<configuration >
<system.web>
<httpRuntime maxRequestLength="1000000" />
</system.web>
</configuration>

همه مقالات کليات ASP.NET را ببينيد.
جستجو: بگرد!
جستجوی پيشرفته
نام کاربری |
کلمه عبور |


IranASP.NET - Mehdi Smart Navigation

Mehdi Smart Navigation

مهدی ميرزايی | اين مقاله ۵۰۰۷ بار تاکنون ديده شده است.
۱۳۸۱/۸/۸ | برای وبلاگ برای وبلاگ
در اين مقاله آقای مهدی ميرزائی سعی کرده است تا با ارائه توضيحات کافی و متن برنامه، امکان Smart Navigation موجود در ASP.NET را در ASP کلاسيک شبيه سازی نمايد.
Mehdi Smart Navigation

در طراحی يک برنامه مبتني بر Web بعضي اوقات نيازمند ايجاد صفحاتي هستيم که بايد بعد از دريافت درخواست کاربر به روز درآيد.
برای مثال در نظر بگيريد صفحه ای داريم که در آن نام کارخانه هاي موجود در بانک اطلاعاتی در يک Combo Box به نمايش در می آيد و در سمت راست آن Combo Box ديگری قرار دارد که خطوط توليد کارخانه انتخاب شده از Combo box قبلی نشان داده می شوند و همينطور در سمت راست Combo Box قبلی محصولات آن خط توليد به نمايش در مي آيد. پس در واقع سه جدول در بانک اطلاعاتي موجود است ، که در Combo box متناظرشان بايد به صورت مناسب به نمايش در آيند. بدين صورت که با انتخاب نام کارخانه از ليست اول نام خطوط توليد آن کارخانه در ليست بعدي نشان داده شود و سپس با انتخاب نام خط توليد نام محصولات آن در لسيت بعدی به نمايش در آيد.
برای پياده سازی اين عمليات بصورت عادی نياز مند به روز رساني صفحه Web در هر مرحله و واکشي اطلاعات از بانک اطلاعاتي هستيم . اما همانطور که مي دانيم به روز رسانی صفحه باعث چشمک زدن آن ، و دريافت يکسري اطلاعات تکراری مي باشد.در يک مقاله به نام Smart Navigation راهی معرفي شده بود برای ASP.NET در IE ، حال به توضيح روشی مي پردازم که در حدود بيش از يک سال است که من در ASP از آن بهره می برم البته اين روش در اکثر Web Browser ها قابل استفاده می باشد (تمام مرور گرهای web ای که DOM 2 را حمايت کنند نظير +NS6 و +IE4 و ... )، حتی مي توانيد آن را به يک ASP.Net Component تبديل نماييد , اساس کار شبيه روش Smart Navigation هست.

روش کار :
صفحه شما تشکيل می گردد از دو فريم :
1) Main : اين فريم همان فريمي است که شما اطلاعاتتان را در آن نمايش می دهيد ، اندازه آن 100% و Norezise هست. که در اينجا GradesList.asp در آن قرار مي گيرد و صفحه اي است که در آن ComboBox ها قرار گيرند.
2) Hidden : اين فريم در واقع با اندازه 0% شکل ميگيرد و NoResize است . در واقع اين Frame از چشم کاربر مخفی است , صفحات درونی آن متغيير و موقتی مورد استفاده قرار می گيرند. که در اينجا وابسته به نياز صفحاتretvFamily.asp , retvGrade.asp , ... در آن قرار می گيرند.

MainPage.htm

<html>
<head>
<title>Untitled Document</title>
<meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">
<meta name="Author" content="Mehdi Mirzaie">
</head>
<frameset rows="258,0" frameborder="NO" border="0" framespacing="0" >
<frame src="GradesList.asp" name="main" frameborder="NO" noresize>
<frame src="javascript:null;" name="hidden" frameborder="NO" noresize>
</frameset>
<noframes>
....
</noframes>
</html>

GradesList.ASP ----------> In Main Frame

<html>
<head><title>Untitled Document</title>
<meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">
</head>
<SCRIPT>
function reloadFamilyComboBox()
{
with(document.SelectGradeForm.Family)
{
innerHTML="";
document.SelectGradeForm.Line.innerHTML = "";
document.SelectGradeForm.Grade.innerHTML = "";
if (document.SelectGradeForm.Manufacturer.value == '') return;
disabled = true;
var oNewNode = document.createElement("OPTION");
oNewNode.innerHTML = "Please wait ..."
appendChild(oNewNode);
window.parent.frames["hidden"].location.href = "retvFamily.asp?ManufacturerID="+document.SelectGradeForm.Manufacturer.value;
}
}

function setFamilyComboBox(IDs,Values)
{
with(document.SelectGradeForm.Family)
{
innerHTML="";
var oNewNode = document.createElement("OPTION");
oNewNode.innerHTML = "Choose One";
appendChild(oNewNode);
var oNewNode = document.createElement("OPTION");
oNewNode.innerHTML = "--------------------";
appendChild(oNewNode);
for (i=0;i<IDs.length;i++)
{
var oNewNode = document.createElement("OPTION");
oNewNode.innerHTML = Values[i];
oNewNode.value = IDs[i];
appendChild(oNewNode);
}
disabled = false;
}

function reloadLineComboBox()
{
with(document.SelectGradeForm.Line)
{
innerHTML="";
document.SelectGradeForm.Grade.innerHTML = "";
if (document.SelectGradeForm.Family.value == '') return;
disabled = true;
var oNewNode = document.createElement("OPTION");
oNewNode.innerHTML = "Please wait ..."
appendChild(oNewNode);
window.parent.frames["hidden"].location.href = "retvLine.asp?FamilyID="+document.SelectGradeForm.Family.value;
}
}

function setLineComboBox(IDs,Values)
{
with(document.SelectGradeForm.Line)
{
innerHTML="";
var oNewNode = document.createElement("OPTION");
oNewNode.innerHTML = "Choose One";
appendChild(oNewNode);
var oNewNode = document.createElement("OPTION");
oNewNode.innerHTML = "--------------------";
appendChild(oNewNode);
for (i=0;i<IDs.length;i++)
{
var oNewNode = document.createElement("OPTION");
oNewNode.innerHTML = Values[i];
oNewNode.value = IDs[i];
appendChild(oNewNode);
}
disabled = false;
}
}

function reloadGradeComboBox()
{
with(document.SelectGradeForm.Grade)
{
innerHTML="";
if (document.SelectGradeForm.Line.value == '') return;
disabled = true;
var oNewNode = document.createElement("OPTION");
oNewNode.innerHTML = "Please wait ..."
appendChild(oNewNode);
window.parent.frames["hidden"].location.href = "retvGrade.asp?LineID="+document.SelectGradeForm.Line.value;
}
}

function setGradeComboBox(IDs,Values,Descriptions)
{
with(document.SelectGradeForm.Grade)
{
innerHTML="";
var oNewNode = document.createElement("OPTION");
oNewNode.innerHTML = "Choose One";
appendChild(oNewNode);
var oNewNode = document.createElement("OPTION");
oNewNode.innerHTML = "--------------------";
appendChild(oNewNode);
for (i=0;i<IDs.length;i++)
{
var oNewNode = document.createElement("OPTION");
oNewNode.innerHTML = Values[i];
oNewNode.value = IDs[i];
oNewNode.title = Descriptions[i]
appendChild(oNewNode);
}
disabled = false;
}
}

</SCRIPT>
<body bgcolor="#FFFFFF" text="#000000" leftmargin=0 topmargin=0>
<form name="SelectGradeForm" method="POST" action="<%=MM_editAction%>">
<table width="558" border="1" cellspacing="0" cellpadding="0" height="87" rules="none" align="center">
<th style='background:silver;' height="20" colspan="5" width="554"><font size="5" face="Georgia, Times New Roman, Times, serif"><font size="3" face="Arial, Helvetica, sans-serif">Select
Grade </font></font></th>
</tr>
<tr>
<td width="554" valign="middle" align="center" height="82">
<table width="81%" border="0" cellspacing="0" cellpadding="0" height="50">
<tr>
<td class="TDClass" height="21">Manufacturer</td>
<td class="TDClass" height="21">Family</td>
<td class="TDClass" height="21">Line</td>
<td class="TDClass" height="21">Grade</td>
</tr>
<tr>
<td height="29">
<% set clsDataBase = Server.CreateObject("Daikin3.clsDatabase")
clsDataBase.ConnectionString = "DSN=Daikin"
set Manufacturers = clsDataBase.GetManufacturers %>

<select name="Manufacturer" style="width:150px;" onChange="reloadFamilyComboBox();">
<option value="">Choose One</option>
<option value="">--------------------</option>
<%for each item in Manufacturers %>
<option value="<%=item.Id%>"><%=item.ManufacturerName%></option>
<%next
set clsDataBase = nothing
set Manufacturers = nothing %>
</select>
</td>
<td height="29">
<select name="Family" style="width:150px;" onChange="reloadLineComboBox();">
</select>
</td>
<td height="29">
<select name="Line" style="width:150px;" onChange="reloadGradeComboBox();">
</select>
</td>
<td height="29">
<select name="Grade" style="width:150px;">
</select>
</td>
</tr>
<tr>
<td>&nbsp;</td>
<td>&nbsp;</td>
<td>&nbsp;</td>
<td>
<div align="center">
<input type="button" name="Button" value="Select" onClick="setGradeNameAndId()";>
</div>
</td>
</tr>
</table>
</td>
</tr>
</table>
</form>
</body>
</html>

توابعي با نام reloadXXXXComboBox برای درخواست اطلاعات جديد و غير معتبر سازی Combo box مورد استفاده قرار می گيرد.
توابعی با نام setXXXXComboBox برای ارسال مقادير جديد و تنظيم Combo Box از فريم Hidden فراخوانی مي گردد.

retvFamily.asp

<%@ Language=VBScript %>
<% ManufacturerId = Request.QueryString("ManufacturerId") %>
<HTML>
<HEAD>
<script language="javascript">
function loadAndSetFamilyDetails()
{
var mainFrame = window.parent.frames["main"];
var frmSrc = mainFrame.location.pathname.toLowerCase() ;
FamilyDetailID = new Array();
FamilyDetailValue = new Array();
<% set clsDataBase = Server.CreateObject("Daikin3.clsDatabase")
clsDataBase.ConnectionString = "DSN=Daikin"
set Families = clsDataBase.GetFamilies(ManufacturerId)
for counter = 1 to Families.Count %>
FamilyDetailID[<%=counter-1%>]="<%= Families(counter).ID %>";
FamilyDetailValue[<%=counter-1%>]="<%=Families(counter).ProductFamilyName%>";
<%next
 set clsDataBase = nothing
set Families = nothing
%>
mainFrame.setFamilyComboBox(FamilyDetailID,FamilyDetailValue);
}
</script>
</head>
<BODY onload="loadAndSetFamilyDetails()">
</BODY>
</html>

retvGrades.asp

<%@ Language=VBScript %>
<% LineId = Request.QueryString("LineId") %>
<HTML>
<HEAD>
<script language="javascript">
function loadAndSetGradeDetails()
{
var mainFrame = window.parent.frames["main"];
var frmSrc = mainFrame.location.pathname.toLowerCase() ;
GradeDetailID = new Array();
GradeDetailValue = new Array();
GradeDetailDescriptoin = new Array();
<% set clsDataBase = Server.CreateObject("Daikin3.clsDatabase")
clsDataBase.ConnectionString = "DSN=Daikin"
set Grades = clsDataBase.GetGrades(LineId)
for counter = 1 to Grades.Count %>
GradeDetailID[<%=counter-1%>]="<%= Grades(counter).ID %>";
GradeDetailValue[<%=counter-1%>]="<%=Grades(counter).ProductGradeName%>";
GradeDetailDescriptoin[<%=counter-1%>]="<%=Grades(counter).TextDescription%>";
<%next
set clsDataBase = nothing
set Grades = nothing
%>
mainFrame.setGradeComboBox(GradeDetailID,GradeDetailValue,GradeDetailDescriptoin);
}
</script>
</head>
<BODY onload="loadAndSetGradeDetails()">
</BODY>
</html>

retvLine.asp

<%@ Language=VBScript %>
<% FamilyId = Request.QueryString("FamilyId") %>
<HTML>
<HEAD>
<script language="javascript">
function loadAndSetLineDetails()
{
var mainFrame = window.parent.frames["main"];
var frmSrc = mainFrame.location.pathname.toLowerCase() ;
LineDetailID = new Array();
LineDetailValue = new Array();
<% set clsDataBase = Server.CreateObject("Daikin3.clsDatabase")
clsDataBase.ConnectionString = "DSN=Daikin"
set Lines = clsDataBase.GetLines(FamilyId)
for counter = 1 to Lines.Count %>
LineDetailID[<%=counter-1%>]="<%= Lines(counter).ID %>";
LineDetailValue[<%=counter-1%>]="<%=Lines(counter).ProductLineName%>";
<%next
set clsDataBase = nothing
set Lines = nothing
%>
mainFrame.setLineComboBox(LineDetailID,LineDetailValue);
}
</script>
</head>
<BODY onload="loadAndSetLineDetails()">
</BODY>
</html>

در واقع هنگاميکه درخواست ديدن صفحه اصلی را می کنيم ، در فريم Main صفحه GradesList.asp ديده می شود که Manufacturer Combo box به صورت پيش فرض در همان صفحه تنظيم می شود. بدين صورت که از يک ActiveX Dll که نوشته بوديم نام کارخانه ها را دريافت نموده ( شما می توانيد مستقيما از بانک اطلاعاتی ، اطلاعات مورد نظرتان را دريافت نماييد.) و سپس OPTION ها بر اساس آن تنظيم می گردد. و سه Combo box ديگر به صورت خالي رها می گردد.
و رويداد OnChange هر کدام به توابع reloadXXXXComboBox متناظرشان نسبت داده مي شود.
حال در نظر بگيريد از نام کارخانه ها يک کارخانه انتخاب می شود ، رويداد OnChange به کار می افتد و تابع reloadFamilyComboBox فراخواني می گردد.

function reloadFamilyComboBox()
{
with(document.SelectGradeForm.Family)
{
/*1*/      innerHTML="";
/*2*/      document.SelectGradeForm.Line.innerHTML =
"";
/*3*/      document.SelectGradeForm.Grade.innerHTML =
"";
/*4*/      if
(document.SelectGradeForm.Manufacturer.value == '') return;
/*5*/      disabled = true;
/*6*/      var oNewNode =
document.createElement("OPTION");
/*7*/      oNewNode.innerHTML = "Please wait
..."
/*8*/      appendChild(oNewNode);
/*9*/
window.parent.frames["hidden"].location.href =
"retvFamily.asp?ManufacturerID="+document.SelectGradeForm.Manufacturer.value;
}
}

با فراخوانی اين تابع با اجرا شدن خط شماره 1 محتويات قبلی Family Combo box خالی مي گردد.و سپس در خط 2 و 3 دو Combo box ديگر خالی مي گردند.
در خط شماره 4 اگر انتخاب حالت None Manufacturer کنترل می شود که اگر صحيح بود از تابع خارج مي گردد در غير اين صورت اگر يه کارخانه اي انتخاب شده بود با اجرا شده خط شماره 5 ، Manufacturer Combo box غيرفعال می گردد و به توسط DOM در خط 7 و 8 Element اي با ارزش يک OPTION ايجاد می گردد و سپس در آن مقدار ... please wait تنظيم می شود و به Combo box اضافه می گردد. و سپس در خط 9 فريم Hidden به صفحه retvFamily.asp با ارسال شماره
هويت نام کارخانه انتخاب شده نسبت داده مي شود.
سپس با اجرا شدن صفحه ASP مورد نظر در Hidden Frame کد JavaScript ای ساخته مي شود.

<%@ Language=VBScript %>
<% ManufacturerId = Request.QueryString("ManufacturerId") %>
<HTML>
<HEAD>
<script language="javascript">
/*0*/ function loadAndSetFamilyDetails()
{
/*1*/   var mainFrame =
window.parent.frames["main"];
/*2*/   var frmSrc =
mainFrame.location.pathname.toLowerCase() ;
/*3*/   FamilyDetailID = new Array();
/*4*/   FamilyDetailValue = new Array();
/*5*/   <% set clsDataBase =
Server.CreateObject("Daikin3.clsDatabase")
/*6*/
clsDataBase.ConnectionString = "DSN=Daikin"
/*7*/         set
Families = clsDataBase.GetFamilies(ManufacturerId)
/*8*/         for
counter = 1 to Families.Count %>
/*9*/
FamilyDetailID[<%=counter-1%>]="<%= Families(counter).ID
%>";
/*10*/
FamilyDetailValue[<%=counter-1%>]="<%=Families(counter).ProductFamilyName%>";
/*11*/    <%next
/*12*/         set
clsDataBase = nothing
/*13*/        set
Families      = nothing
%>
/*14*/
mainFrame.setFamilyComboBox(FamilyDetailID,FamilyDetailValue);
}
</script>
</head>
<!--/* 15 */  --><BODY
onload="loadAndSetFamilyDetails()">
</BODY>
</html>

در خط 1 تابعی به نام loadAndSetFamilyDetails تعريف مي گردد. و در خط شماره 1 از طريق DOM به شی Main Frame دسترسی پيدا می نماييم.
در خط شماره 3 و 4 دو آرايه به وجود می آوريم و به واسطه خطوط 5 الی 13 خانه هاي آرايه را از اطلاعات موجود در Database پر می نماييم. در واقع اطلاعات Family کارخانه انتخاب شده در مرحله قبلی و سپس در خط 14 درخواست فراخواني تابع setFamilyComboBox با ارسال دو آرايه مورد نظر که شامل نام Family و شماره هويت آنها ست مي نماييم. تابع setFamilyComboBox در صفحه GradesList.asp قرار دارد به همين خاطر به واسطه شی MainFrame آن را فراخوانی مي نماييم. اما خود تابع loadAndSetFamilyDetails در خط 15 در هنگام Load شدن اين صفحه فراخوانی مي گردد.
پس بعد از فراخوانی loadAndSetFamilyDetails در نهايت تابع setFamilyComboBox فراخوانی مي شود.

function setFamilyComboBox(IDs,Values)
{
with(document.SelectGradeForm.Family)
{
/*1*/     innerHTML="";
/*2*/      var oNewNode =
document.createElement("OPTION");
/*3*/      oNewNode.innerHTML = "Choose One";
/*4*/      appendChild(oNewNode);
/*5*/      var oNewNode =
document.createElement("OPTION");
/*6*/      oNewNode.innerHTML =
"--------------------";
/*7*/      appendChild(oNewNode);
/*8*/      for (i=0;i<IDs.length;i++)
{
/*9*/          var oNewNode =
document.createElement("OPTION");
/*10*/          oNewNode.innerHTML =
Values[i];
/*11*/          oNewNode.value = IDs[i];
/*12*/          appendChild(oNewNode);
}
/*13*/     disabled = false;
}
}

با اجرا شدن خط شماره 1 Family Combo Box تمام اعضاي قبليش را از دست می دهد و خالی می گردد در واقع نمايش ... please wait از بين مي رود و سپس از طريق DOM عنصر OPTION اي ساخته می شود با مقدار نمايشی نام Family مورد نظر و ارزشی معادل هويت Family مورد نظر البته براي ايجاد نمودن تعداد OPTION لازم با بدست آوردن تعداد خانه هاي آرايه و بک حلقه For اين کار ميسر مي گردد و سپس اين OPTION ها به شی Combo box مورد نظر اضافه مي گردند و نهايتا وضعيت غيرفعالی که در مرحله اجرا شدن تابع reloadFamilyComboBox بوحود آمده بود در اينجا به وضعيت فعال تغيير می کند.
در واقع کار تمام شد و بدوند Refresh شدن صفحه GradesList.asp اطلاعات موجود در Combo box ها اصلاح گشت برای ديگر Combo box ها نيز کار به همين صورت است که شما کد آن را مي توانيد ملاحظه فرماييد.

همه مقالات ASP کلاسيک را ببينيد.
جستجو: بگرد!
جستجوی پيشرفته
نام کاربری |
کلمه عبور |


IranASP.NET - آشنائی با کنترل AdRotator

آشنائی با کنترل AdRotator

سيد امين پوريه | اين مقاله ۳۹۹۷ بار تاکنون ديده شده است.
۱۳۸۱/۸/۱۴ | برای وبلاگ برای وبلاگ
با استفاده از كنترل AdRotator می توان آگهی های تبليغاتی را در يك سايت به صورت دلخواه نمايش داد.

يكی از كنترلهای طرف سرور می باشد. اين كنترل برای كار نياز به Rotator Schedule دارد كه يك فايل با فرمت XML است. اين فايل را از طريق خصوصيت (Properties) Advertisement File به كنترل AdRotator معرفی می شود.

File :AdRotator.aspx
<%@ Page Language="VB" %>
<html>
<body>
<H1>AdRotator in ASP.NET</H1>

<asp:AdRotator id=MyAdRotator runat=server
AdvertisementFile="Advertisement.xml"
BorderWidth=2 />

</body>
</html>

عنصر ريشه (Root Element) در فايل XML مذكور Advertisements می باشد. اين عنصر بسته به تعداد آگهی های تبليغاتی دارای يك يا چند عنصر فرزند (Child Element) به نام Ad است. هر كدام از عناصر <Ad> شامل تعدادی توصيف كننده می باشد كه در ذيل به آنها اشاره ميگردد.

File : Advertisement.xml
<Advertisements>
<Ad>
<ImageUrl>images/banner1.gif</ImageUrl>
<NavigateUrl>http://www.Iranasp.net</NavigateUrl>
<AlternateText>ASP.NET</AlternateText>
<Keyword>ASP</Keyword>
<Impressions>5</Impressions>
</Ad>

<Ad>
<ImageUrl>images/banner2.gif</ImageUrl>
<NavigateUrl>http://www.Pishgaman.com</NavigateUrl>
<AlternateText>YAZDISP</AlternateText>
<Keyword>ISP</Keyword>
<Impressions>5</Impressions>
</Ad>
</Advertisements>

• Image URL: URLای است كه گرافيكی كه مربوط به اين تبليغ است و بايد در آنجا يافت شود.
• URL Navigate: URL ای كه كاربر با كليك كردن بر روی اين تبليغ به آنها متصل ميشود.
• Alternate Text: متنی كه هنگامی كه گرافيكها از ديد كاربر پنهان است نمايش داده ميشود.
• Keyword: كليد واژه مرتبط با هر آگهی تبليغاتی.
• Impressions: مقدار اهميت يك آگهی تبليغاتی را نشان می دهد.

كنترل AdRotator با انتخاب يك تبليغ از فايل XML (بصورت تصادفی) و پردازش آن، نتيجه را به صورت HTML به طرف Client می فرستد (لازم به ذكر است ميتوان با تغيير مقدار Imperssions برای هر تبليغ تعداد دفعات نمايش آن تبليغ را كم يا زياد نمود).

اين كنترل توانايی فيلتر نمودن تبليغات را نيز دارد بدين صورت كه می توان با تنظيم خاصيت Keyword Filter فقط تبليغاتی را مشاهده نمود كه با آن كليد واژه همراه هستند.

به عنوان مثال كد زير تنها تبليغ مربوط http://www.iranasp.net را نشان ميدهد.

File :AdRotator.aspx
<asp:AdRotator id=MyAdRotator runat=server
AdvertisementFile="Advertisement.xml"
KeywordFilter="ASP"
BorderWidth=2 />

منابع:
http://www.123aspx.com
http://www.aspnextgen.com

همه مقالات فرم های وب را ببينيد.
جستجو: بگرد!
جستجوی پيشرفته
نام کاربری |
کلمه عبور |


IranASP.NET - Caching در ASP.NET

Caching در ASP.NET

مديريت سايت | اين مقاله ۴۴۶۵ بار تاکنون ديده شده است.
۱۳۸۱/۸/۲۱ | برای وبلاگ برای وبلاگ
بررسی مساله Caching در ASP.NET از طريق معرفی انواع آن که عبارتند از Fragment Caching ،Page Output Caching و Data Caching.

۱- مقدمه ای بر Caching در ASP.NET

• Caching عبارت است از قرار دادن حاصل اجرای يک صفحه در يک حافظه سريع جهت دسترسی سريع و استفاده مجدد از آن در ارجاعات بعدی.
• Caching مهمترين فاکتور در ايجاد يک برنامه تحت وب با توانائی و کارائی بالا می باشد.
• محل های Caching عبارتند از Web server, proxy server و client browsers.
• انواع Caching عبارتند:

Output caching
Fragment caching
Data caching

۲- Output Caching

Output Caching چيست؟
• صفحاتی که از Output Caching استفاده می کنند برای بار اول اجرا می شوند و سپس حاصل آن cache می گردد. جهت پاسخگوئی به درخواستهای بعدی برای همين صفحه، از نسخه cache شده استفاده می گردد.
• فوايد Output Caching در کاهش محسوس زمان پاسخ دهی سرور و کاهش بار اضافی بر روی CPU در سرور می باشد.
• استفاده صحيح از Output Caching سرعت و کارائی سايت را بطور محسوسی افزايش می دهد.
• از Output Caching می توان در فايل های با پسوند asmx. ،.aspx و ascx. استفاده نمود.
• با استفاده از دايرکتيو OutputCache @ در بالای فايلهای فوق بصورت زير می توان Output Caching را فعال کرد:

<%@ OutputCache Duration="600" Location="Any" VaryByParm="none" %>

• يا از درون برنامه بصورت زير هم می توان اين کار را انجام داد:

[C#]
Response.Cache.SetExpires(DateTime.Now.AddSeconds(600));
Response.Cache.SetCacheability(HttpCacheability.Public);

صفات OutputCaching
• Duration: مدت زمان معتبر بودن cache را مشخص می کند. مقداردهی اين صفت الزامی است و مقدار آن بر اساس ثانيه است.

• Location: محل قرار گرفتن cache را مشخص می کند.
در حالت Server صفحه cache شده در حافظه سرور نگهداری می شود.
در حالت Downstream صفحه cache شده بر روی proxy server نگهداری می گردد.
در حالت Client صفحه cache شده بر روی مرورگر کاربر قرار می گيرد.
در حالت Any صفحه cache شده بر روی هر يک از موارد فوق می تواند قرار گيرد.
در حالت None صفحه مربوطه عملا در هيچ کجا cache نخواهد شد.

• VaryByParam: نسخه های cache متفاوتی از صفحه مورد نظر براساس پارامترهای موجود در QueryString و Form يا ترکيبی از آنها ايجاد می گردد.

<%@ OutputCache Duration="10" VaryByParam="location;count" %>

• VaryByHeader: نسخه های cache متفاوتی براساس مقادير مختلف پارامتر تعيين شده در HTTP header ايجاد می گردد.

<%@ OutputCache Duration="60" VaryByHeader="Accept-Language" %>

• VaryByCustom: اگر مقدار اين صفت کلمه خاص "Browser" باشد، cache مورد نظر براساس نوع و نسخه اصلی مرورگرايجاد خواهد شد. اگر مقدار آن يک رشته دلخواه باشد، آنگاه لازم است که شما متد HttpApplication.GetVaryByCustomString را در فايل Global.asax را بگونه دلخواه بازنويسی کنيد.

۳- Fragment Caching

• علاوه بر اينکه شما می توانيد تمام يک صفحه را cache کنيد، شما حتی می توانيد بخشی از يک صفحه را cache کنيد. به اين عمل Fragment Caching گويند.
• بدين منظور لازم است که شما بخش های مورد نظر را بصورت User Control يا کنترل کاربری ايجاد کرده باشيد.
• هر کنترل کاربری دايرکتيو OutputCache@ مخصوص به خود را دارا می باشد.
• صفات مورد استفاده در اينجا عبارتند از VaryByParam و VaryByControl.
• امکان تعيين محل cache با استفاده از صفت Location مقدور نمی باشد و محل cache همواره بر روی سرور در نظر گرفته می شود.

• VaryByControl: ششمين صفت موجود در دايرکتيو Outputcache@ می باشد. تنها می توان در کنترلهای کاربری از آن استفاده کرد. استفاده از آن سبب می شود تا cacheهای متعددی براساس خواص (properties) کنترل کاربری ايجاد گردد.

[*.ascx]
<%@ Language="C#" %>
<%@ OutputCache Duration="10" VaryByControl="State;Country" VaryByParam="*"%>
<script runat=server>
public String State {
get { return state.Value; }
set { state.Value = State; } }

public String Country {
get { return country.Value; }
set { country.Value = Country; } }
</script>

• می توان بصورت تودرتو از کنترلهای کاربری با قابليت cache استفاده نمود. در اين صورت يک cache سلسله مراتبی بسيار قدرتمند خواهيم داشت. اين مساله اگر چه نياز به هيچ نوع برنامه نويسی خاصی ندارد اما می تواند سبب مصرف حافظه زيادی گردد.
• سعی نکنيد بصورت برنامه ای به يک کنترل کاربری موجود در cache دسترسی داشته باشيد. در غير اين صورت شما با يک exception برخورد خواهيد کرد. زيرا اين نوع کنترلها در درخت کنترلهای موجود قرار نمی گيرند.

۴- Data Caching

• با استفاده از data cache می توان داده های برنامه مانند رشته ها، DataSetها و ساير اقلام داده و آبجکت را بصورت زير cache کرد:

Cache ("counter") = mycount.text

• اگرچه اين مساله مانند استفاده از متغيرهای از نوع Application است، اما بسيار قوی تر و کارآمدتر می باشد.
• هر قسمت از برنامه که از داده های موجود در cache استفاده می کند، بايد قادر باشد تا در صورت غيرمعتبر بودن cache، بتواند آن را دوباره بسازد.

Public Function GetProductData() As DataSet
If (IsNothing(Cache("ProductData")) Then
Cache("ProductData") = LoadDataSet()
End If
Return Cache("ProductData")
End Function

• توصيه می شود جهت استفاده از cache همواره از مدل فوق استفاده نمائيد.
• جهت داشتن کنترل بيشتر بر cache يا استفاده از امکانات پيشرفته آن از متدهای Cache.Insert و Cache.Add استفاده نمائيد.
• با استفاده از متد Cache.Remove می توانيد داده مورد نظر را از cache حذف نمائيد.

همه مقالات کليات ASP.NET را ببينيد.
جستجو: بگرد!
جستجوی پيشرفته
نام کاربری |
کلمه عبور |


IranASP.NET - انتقال مقادير بين صفحات يک برنامه

انتقال مقادير بين صفحات يک برنامه

مديريت سايت | اين مقاله ۵۳۵۶ بار تاکنون ديده شده است.
۱۳۸۱/۹/۳ | برای وبلاگ برای وبلاگ
در اين مقاله با يک روش جديد و مختص ASP.NET بنام Context جهت تبادل مقادير ميان صفحات يک برنامه آشنا می شويد.

ASP.NET دارای امکانات خوبی جهت انتقال مقادير و متغيرها ميان صفحات می باشد. خوشبختانه علاوه بر امکان استفاده از روش های قديمی مانند متغيرهای Application ،Session و QueryString، قابليت جديدی نيز به اين مجموعه اضافه شده است که بسيار کارآمد هم می باشد. اين امکان جديد شئ Context می باشد و از اين قابليت می توان در کنار Server.Transfer بخوبی استفاده نمود. استفاده از Context همانند استفاده از Session است:

Context.Items.Add("NameOfVariable","ValueOfVariable");
Server.Transfer("WebForm2.aspx");

در صفحه دوم جهت بازيابی مقدار ذخيره شده بصورت زير عمل می کنيم:

Label1.Text=Context.Items["NameOfVariable"].ToString();

بنابراين، در صفحه دوم می توانيم مقدار ارسالی را در قالب يک شئ از تايپ object دريافت کنيم که لازم است قبل از استفاده، آن را به تايپ مورد نظر تبديل يا Cast کنيم. اين روش شايد برای تعداد محدودی از مقادير يا متغيرها کارآمد باشد، اما اگر تعداد زيادی از اين متغيرها را بخواهيم به ازای هر کاربر يا Session نگهداری کنيم در اين صورت ممکن است دچار مشکل شويم يا به علت اشکالات تايپی در نام اين نوع متغيرها به خطای منطقی در برنامه برخورد نمائيم. جهت حل اين معضل از روش زير استفاده می کنيم.

Imports System.Collections
Public Class StaticContainer
Private Shared thing As Hashtable
Public Shared Sub InitThing()
thing = New Hashtable()
End Sub
Public Shared Sub KillThing()
thing.Clear()
thing = Nothing
End Sub
Public Shared Sub AddContainer(ByVal key As Object)
thing.Add(key, New ArrayList())
End Sub
Public Shared Sub RemoveContainer(ByVal key As Object)
thing.Remove(key)
End Sub
Public Shared Sub AddToContainer(ByVal newname As String, ByVal index As Integer,
ByVal stuff As String, ByVal key As Object)
Dim temp As ArrayList = thing.Item(key)
thing.Remove(key)
Dim t As New triple()
t.name = newname
t.ID = index
t.data = stuff
temp.Add(t)
thing.Add(key, temp)
End Sub
Public Shared Function GetEntry(ByVal x As Integer, ByVal key As Object) As triple
Dim temp As ArrayList = thing.Item(key)
Dim result As triple
If temp.Count > x And x >= 0 Then
result = CType(temp(x), triple)
End If
Return result
End Function
End Class
Public Structure triple
Public name As String
Public ID As Integer
Public data As String
End Structure

جهت استفاده از کلاس فوق لازم است در فايل Global.asax تغييرات زير را اعمال کنيم:

Sub Application_Start(ByVal sender As Object, ByVal e As EventArgs)
' Fires when the application is started
StaticContainer.InitThing()
End Sub
Sub Session_Start(ByVal sender As Object, ByVal e As EventArgs)
' Fires when the session is started
Session.Add("key", DateTime.Now.Ticks.ToString("x"))
StaticContainer.AddContainer(Session.Item("key"))
End Sub
Sub Session_End(ByVal sender As Object, ByVal e As EventArgs)
' Fires when the session ends
StaticContainer.RemoveContainer(Session.Item("key"))
End Sub
Sub Application_End(ByVal sender As Object, ByVal e As EventArgs)
' Fires when the application ends
StaticContainer.KillThing()
End Sub

برای ذخيره شناسه يا ID مربوط Container و کاربر از Session استفاده نموديم. هنگامی که برنامه برای اولين بار اجرا می شود Hashtable مورد نظر ايجاد شده و هنگامی که Session شروع می شود فضای مربوط به نگهداری مقادير به ازای هر کاربر نيز ايجاد می گردد. نحوه استفاده از اين برنامه فوق بصورت زير است:

StaticContainer.AddToContainer(TextBox1.Text, Integer.Parse(TextBox2.Text),
TextBox3.Text, Session.Item("key"))

Dim t As triple = StaticContainer.GetEntry(Integer.Parse(TextBox4.Text), Session.Item("key"))
ListBox1.Items.Add(t.name)
ListBox1.Items.Add(t.ID.ToString())
ListBox1.Items.Add(t.data)

همانگونه که ملاحظه می فرمائيد ديگر نيازی به تبديل به تايپ های مختلف نداشته و در عوض بجای ساختار triple شما هر نوع ساختاری را با هر نوع تعداد متغير را می توانيد تعريف و استفاده نمائيد.

منبع: http://www.dotnetjunkies.com/tutorials.aspx?tutorialid=600

همه مقالات کليات ASP.NET را ببينيد.
جستجو: بگرد!
جستجوی پيشرفته
نام کاربری |
کلمه عبور |


IranASP.NET - پارامترها در ADO.NET

پارامترها در ADO.NET

مديريت سايت | اين مقاله ۶۷۴۴ بار تاکنون ديده شده است.
۱۳۸۱/۹/۲۶ | برای وبلاگ برای وبلاگ
برای ساخت عبارتهای SQL بهتر است که از پارامترها استفاده کنيد. در اين مقاله با اين پارامترها و نحوه تعريف و بکارگيری آنها آشنا می شويد.

اگر تجربه استفاده از نگارشهای قديمی تر ASP کلاسيک را داشته باشيد احتمالا با ساختار زير آشنا هستيد. اين مثال با استفاده از مقادير بدست آمده از يک فرم، يک عبارت SQL می سازد:

MySQL = "SELECT CustomerID, CompanyName, ContactName, City, Country, Phone " & _
"FROM Customers " & _
"WHERE " & _
"Country IN (" & _
" ' " & Request("Country1") & "', " & _
" ' " & Request(Country2") & "')" & _
CompanyName >='" & Request("StartRange") "' " & _
"OREDR By CompanyName"

به علاوه احتمالا می دانيد که برای تضمين اجرای SQL خود بايد روی قالب داده کار بيشتری انجام دهيد (کارهايی از قبيل جايگزين کردن علامتهای نقل قول تکی با علامتهای نقل قول دوتايی، سنجش اعتبار انواع داده ها و غيره).

ASP.NET با معرفی عبارتهای SQL پارامتری شده اين فرآيند را حذف می کند. کافی است با استفاده از مجموعه Parameters از کلاس Command پارامترهای مورد نظر خود را تعريف کنيد.

پارامتری کردن کلاس Command چند فايده دارد. به سنجش اعتبار داده ها کمک می کند، خوانائی کد را تقويت می کند، انعطاف پذيری طراحی شئ گرا را به همراه می آورد، و از همه مهمتر اين که امکان تعريف صريح نوع داده را فراهم می کند. از آنجائی که اطلاعات نوع داده در کد ASP.NET کامپايل می شود، تعيين نوع داده در زمان اجرا توسط سرويس دهنده SQL انجام نمی شود، و اين باعث افزايش سرعت اجرا می گردد. جهت آشنائی با کلاس های SQLParameters و SQLParameter به راهنمای مربوطه مراجعه نمائيد.

اکنون با استفاده از اين دو کلاس مثال اوليه SQL فوق را بصورت پارامتری می سازيم. به خاطر داشته باشيد که ابتدا فضانام های ضروری را در برنامه تان وارد کنيد. در اين مثال خاص ما قصد داريم که از فضانام SqlClient استفاده کنيم. لذا فضانام های زير را بايد تعريف کنيم:

<%@ Import Namespace="System.Data" %>
<%@ Import Namespace="System.Data.SqlClient" %>

حالا بايد متغيرها را تعريف و مقداردهی اوليه کنيم:

Dim MyConnection As SQLConnection
Dim MyCommand As SQLCommand
Dim MySQL As String

برای ساخت دستور SQL، شناسه های متغير را درج می کنيم که با علامت @ در جاهای مناسب نشان داده می شوند (يک بار ديگر تاکيد می کنيم که برای ساخت مؤثر برنامه های کاربردی وب مبتنی بر داده ها داشتن درکی کامل از SQL ضروری است). سپس مقادير اين شناسه ها را با استفاده از متدها و خصوصيتهايی که قبلا توصيف شدند مشخص می کنيم:

MyConnection = New SQLConnection("server=localhost;uid=sa;pwd=;dsn=Northwind")
MySQL = "SELECT CustomerID, CompanyName, ContactName, City, Country, Phone " & _
"FROM Customers " & _
"WHERE " & _
"Country IN (@Country1, @Country2) AND " & _
"CompanyName >= @StartRange " & _
"ORDER BY Country, CompanyName"

'Create the SQLCommand using the connection and SQL string.
MyCommand = New SQLCommand(MySQL, MyConnection)

در اين لحظه پارامترهای SQL را به مجموعه Parameters از شئ SQLCommand که نمونه سازی کرده ايم اضافه می کنيم:

' Specify the name, type and size of the parameters to add to the collection
MyCommand.Parameters.Add(New SQLParameter("@Country1", SQLDataType.VarChar, 50))
MyCommand.Parameters.Add(New SQLParameter("@Country2", SQLDataType.VarChar, 50))
MyCommand.Parameters.Add(New SQLParameter("@StartRange", SQLDataType.VarChar, 1))

'Assign values to these parameters... in many situations this would be requested from the form object
'and would not actually be hard coded as we do in this example.
MyCommand.Parameters("@Country1").Value = "Germany"
MyCommand.Parameters("@Country1").Value = "UK"
MyCommand.Parameters("@StartRange").Value = "D"

توجه داشته باشيد که فضانام OleDb برای مشخصات نوع داده، خصوصيتی به نام OleDBType دارد که تا حدودی متفاوت است.

در زير يک ترکيب نحوی ديگر برای انجام همين کار می آوريم و آن هم عبارت است از افزودن سه پارامتر به شئ SQLCommand. فرق بين اين دو تنها در خوانايی و ترجيح برنامه نويس است.

Dim pCountry1 As New SQLParameter("@Country1", SQLDataType.VarChar, 50)
Dim pCountry2 As New SQLParameter("@Country2", SQLDataType.VarChar, 50)
Dim pStartRange As New SQLParameter("@StartRange", SQLDataType.VarChar, 1)

MyCommand.Parameters.Add(pCountry1)
MyCommand.Parameters.Add(pCountry2)
MyCommand.Parameters.Add(pStartRange)

pCountry1.Value = "Germany"
pCountry1.Value = "UK"
pStartRange.Value = "D"

برای ديدن نتايج عبارت SQL پارامتری شده، از شئ SQLDataReader و برای نشان دادن نتايج صفحه نمايش، از کنترل DataGrid استفاده کرده ايم:

MyConnection.Open()
Dim myDR As SQLDataReader = myCommand.ExecuteReader()
MyDataGrid.DataSource = myDR
MyDataGrid.DataBind()
MyConnection.Close()

(برگرفته از کتاب آموزشی ASP.NET از انتشارات کانون نشر علوم)

همه مقالات ADO.NET و پايگاه داده را ببينيد.
جستجو: بگرد!
جستجوی پيشرفته
نام کاربری |
کلمه عبور |


IranASP.NET - ViewState و نگهداری مقادير فرمها - قسمت اول

ViewState و نگهداری مقادير فرمها - قسمت اول

علی رئيس دانا | اين مقاله ۴۳۵۴ بار تاکنون ديده شده است.
۱۳۸۱/۱۰/۲۸ | برای وبلاگ برای وبلاگ
در ASP کلاسيک بعد از تائيد يک فرم اطلاعات ورودی از بين می رود. برای رفع اين عيب در ASP.NET از ViewState استفاده می شود.

دکمه Back را فشار دهيد... چه اتفاقی افتاده است؟ بله همه داده های ورودی پاک شده و شما مجبوريد دوباره از ابتدا شروع کنيد. اين صفحه از ViewState پشتيبانی نمی کند!

در ASP.NET وقتی يک فرم تائيد (ارسال) می شود اگر دوباره به صفحه حاوی فرم برگرديد فرم را با تمام داده های ورودی مشاهده خواهيد کرد. چطور!؟ به اين دليل که ASP.NET بطور خودکار و با کمک ViewState مقادير ورودی شما را نگهداری می کند. درواقع ViewState وضعيت مقادير موجود در يک صفحه را هنگام تائيد و ارسال صفحه به سرويس دهنده (سرور)، نگهداری می کند. طرز کار بسيار ساده است: اين عمل با قرار دادن يک فيلد مخفی (Hidden Field) انجام می شود. اين فيلد به هر صفحه ای که شامل تگ <Form runat="server"> باشد، بطور خودکار و توسط ASP.NET افزوده خواهد شد. کدی که اضافه می شود شبيه به کد زير می باشد:

<Form name="_ct10" method="post" action="page.aspx" id="_ct10">
<input type="hidden" name="__VIEWSTATE" value="dDwtNTI0ODU5MDE1Ozs+ZBCF2ryjMpeVgUrY2eTj79HNl4Q" />
some code
</form>

نگهداری ViewState يکی از تنظيمات پيش فرض ASP.NET برای WebForm ها می باشد. اگر شما نيازی به ViewState نداريد دستور رهنمون يا Directive زير را به بالای صفحه aspx خود اضافه کنيد:

<% @Page EnableViewState="false" %>

همچنين می توانيد صفت EnableViewState را برای کنترل مورد نظر خود تنظيم نمائيد.

[ASPX page]
<asp:label id="myLabel" runat="server" EnableViewState="false"></asp:label>

[codebehind]
myLabel.EnableViewState = false

در ادامه مثالی جهت آزمايش ViewState ارائه می شود:

<script runat="server">
Sub submit(sender As Object, e As EventArgs)
lbl1.Text="Hello " & txt1.Text & "!"
End Sub
</script>
<html>
<body>
<form runat="server">
Your name: <asp:TextBox id="txt1" runat="server" />
<asp:Button OnClick="submit" Text="Submit" runat="server" />
<p><asp:Label id="lbl1" runat="server" /></p>
</form>
</body>
</html>

ViewState و نگهداری مقادير فرمها - قسمت دوم

همه مقالات فرم های وب را ببينيد.
جستجو: بگرد!
جستجوی پيشرفته
نام کاربری |
کلمه عبور |


IranASP.NET - ViewState و نگهداری مقادير فرمها - قسمت دوم

ViewState و نگهداری مقادير فرمها - قسمت دوم

مديريت سايت | اين مقاله ۴۴۷۰ بار تاکنون ديده شده است.
۱۳۸۱/۱۰/۲۸ | برای وبلاگ برای وبلاگ
در ASP کلاسيک بعد از تائيد يک فرم اطلاعات ورودی از بين می رود. برای رفع اين عيب در ASP.NET از ViewState استفاده می شود.

ViewState و نگهداری مقادير فرمها - قسمت اول

بطورکلی هر تايپی که اصطلاحا serializable بوده يا يک TypeConverter برای آن تعريف شده باشد، می تواند در ViewState ذخيره گردد. بهرحال توجه داشته باشيد که تايپ هائی که تنها دارای قابليت serializable باشند نسبت به آنهائی که دارای TypeConverter می باشند کندتر بوده و در ViewState حجم بيشتری از داده را نگهداری می کنند. بطورکلی می توان از کليه تايپ های اوليه مانند عدد، حرف و غيره به همراه رشته های حرفی يا ArrayList ،String و HashTable استفاده نمود.

شما بعنوان يک برنامه نويس بايد دقت داشته باشيد که کليه داده های موجود در ViewState در هر بار رفت و برگشت صفحات يا اصطلاحا round-trip همراه صفحات منتقل می شوند و اين مساله می تواند از جهت سرعت دريافت صفحات يا امنيت اطلاعات قابل توجه باشد. بعبارت ديگر اگر خواهان صفحات سبکتری هستيد نبايد اطلاعات زيادی را در ViewState نگهداری کنيد يا اينکه به هيچ عنوان اطلاعات محرمانه مانند کلمه رمز، عبارت اتصال به بانک اطلاعاتی (Connection String) و غيره را در ViewState نگهداری نکنيد.

جهت انجام اين کار لازم است که بدانيد علاوه بر يک فرم وب يا صفحه، هر يک از کنترلهای موجود در يک فرم وب نيز دارای يک صفت بنام EnableViewState می باشند که بصورت موردی می توانيد تعيين کنيد که آيا اطلاعات کنترل مورد نظر در ViewState ذخيره گردد يا خير. يکی از بهترين کاربردهای اين صفت می تواند در مورد کنترلهای Repeater ،DataList و يا DataGrid باشد که همواره حجم زيادی از اطلاعات را در ViewState نگهداری می کنند و در اکثر موارد ممکن است که به اين اطلاعات نيازی نداشته باشيم. لذا با false قرار دادن مقدار صفت EnableViewState برای اين کنترلها می توانيم سرعت دريافت صفحات خود را بطور چشمگيری افزايش دهيم.

همچنين شما می توانيد اطلاعات مورد نظر خود را بجای ذخيره در Session، در ViewState قرار دهيد. اين کار بصورت زير انجام می گردد:

[C#]
ViewState["MyData"] = "This is some data.";

[VB.NET]
ViewState("MyData") = "This is some data."

همانطور که می بينيد لازم است نام يا کليدی را برای اطلاعات خود در ViewState تعيين نمائيد تا اطلاعات شما تحت آن نام در ViewState ذخيره و قابل بازيابی باشد. اين اطلاعات را می توانيد پس از رفت و برگشت صفحه بصورت زير بازيابی نمائيد:

[C#]
string strTmp = (string) ViewState["MyData"];

[VB.NET]
Dim strTmp As String = CStr(ViewState["MyData"])

در مثال زير يک کلاس فرضی برای کنترل Label را مشاهده می کنيد که برای ذخيره متن و اندازه فونت خود از ViewState استفاده نموده است.

[VB.NET]
' This control renders values stored in view state for Text and FontSize properties.

Imports System
Imports System.Web
Imports System.Web.UI

Namespace ViewStateControlSamples

Public Class LabelVB : Inherits Control

' Add property values to view state with set;
' retrieve them from view state with get.
Public Property [Text] As String
Get
Return CStr(ViewState("Text"))
End Get
Set
ViewState("Text") = Value
End Set
End Property

Public Property FontSize As Integer
Get
Return CInt(ViewState("FontSize"))
End Get
Set
ViewState("FontSize") = Value
End Set
End Property

Protected Overrides Sub Render(Output As HtmlTextWriter)
Output.Write("<font size=" & Me.FontSize & ">" & Me.Text & "</font>")
End Sub

End Class

End Namespace

[C#]
// This control renders values stored in view state for Text and FontSize properties.
using System;
using System.Web;
using System.Web.UI;

namespace ViewStateControlSamples {

public class Label: Control {

// Add property values to view state with set;
// retrieve them from view state with get.
public String Text {
get {
return (String) ViewState["Text"];
}
set {
ViewState["Text"] = value;
}
}

public int FontSize {
get {
return (int) ViewState["FontSize"];
}
set {
ViewState["FontSize"] = value;
}
}

protected override void Render(HtmlTextWriter output) {
output.Write("<font size=" + this.FontSize + ">" + this.Text + "</font>");
}
}
}

همه مقالات فرم های وب را ببينيد.
جستجو: بگرد!
جستجوی پيشرفته
نام کاربری |
کلمه عبور |


IranASP.NET - کنترلهای مخفی

کنترلهای مخفی

سيد محمد سعيد موسوی | اين مقاله ۵۲۰۴ بار تاکنون ديده شده است.
۱۳۸۱/۱۱/۷ | برای وبلاگ برای وبلاگ
اين مقاله به بررسی کنترلهای مخفی يا hidden در فرم ها پرداخته و کاربرد آن را شرح می دهد.

شايد تابحال اين سؤال برايتان پپش آمده باشد كه صفت hidden در کنترلها چه كاربردی دارد و اصولا کنترلی كه مخفی باشد به چه دردی می خورد؟ من در اين مقاله سعی براين دارم كه با نشان دادن كاربردهايی از اين کنترلها، كارايی آنها را برايتان شرح دهم.

يك کنترل مخفی در اصل يك فيلد textbox است كه از ديد كاربر مخفی می ماند. اگر تاكنون برای صفحات وب برنامه نويسی كرده باشيد، حتما تاكنون به مواردی برخورد كرده ايد كه لازم بوده کنترلی برای دريافت اطلاعات از كاربر در صفحه قرار دهيد و درصورتی كه كاربر قبلا اين کنترل را submit كرده باشد، ديگر نيازی به نمايش آن کنترل نداشته باشيد. در واقع اگر كاربر قبلا اين کنترل را تكميل كرده باشد، ديگر نيازی نيست که اين کنترل نمايش داده شود.

برای اين منظور يك textbox مخفی با نام process و مقدار true در فرم مربوطه ايجاد كنيد.

<input type=hidden name=process value=true>

بعد action فرم حاوی آن کنترل را به همان صفحه قرار دهيد. در ابتدای شروع تگ Form مقدار متغير process را چك كنيد. اگر اين اولين باری باشد كه كاربر اين صفحه را مشاهده می كند، متغير process هيچ مقداری نداشته و خالی خواهد بود. اما اگر او قبلا کنترل شما را submit كرده باشد متغير process مقدار true خواهد داشت. در زير نمونه كدی را كه برای اين منظور بايد استفاده شود را آورده ام:

If Request.Form("process") Then
RunFunction
Else
Show MyForm
EndIf

دومين راه استفاده از کنترلهای مخفی، قرار دادن اطلاعاتی در کنترل ميباشد كه شما می خواهيد يا آنها از صفحه ای به صفحه ديگر منتقل كنيد و يا اطلاعاتی را كه خودتان بوجود آورده ايد (مثل UserId كه بعد از login كردن هر كاربر توليد می شود) بين صفحات انتقال دهيد.

جای ديگری كه در آنجا استفاده از کنترلهای مخفی رايج می باشد، در صفحاتی است كه تعداد خاصی از ركوردهای يك بانك اطلاعاتی را در يك صفحه نمايش داده و با استفاده از دكمه های Next و Prev امكان ديدن تعداد ركوردهای بعدی را درصفحه بعد، فراهم می آورند. برای اين منظور بعداز Submit كردن يك پرسش (يا فشردن يك دكمه مثل Next) نياز به رد كردن تعداد ركوردهايی كه تا صفحه قبل نمايش داده بوديم داريم. در اين روش وقتی كه كاربر روی دكمه Next، مثلا برای نمايش ۵۰ ركورد بعدی كليك می كند، تعداد ركوردهای گذشته را كه نمايش داده شده اند، توسط مقدار يك Textbox مخفی به آن صفحه می فرستيم. سپس از اين مقدار در عبارت SQL برای بدست آوردن ركوردهای موردنظر استفاده می كنيم.

همه مقالات ASP کلاسيک را ببينيد.
جستجو: بگرد!
جستجوی پيشرفته
نام کاربری |
کلمه عبور |


IranASP.NET - ارسال نامه در ASP.NET از نگاهی ديگر

ارسال نامه در ASP.NET از نگاهی ديگر

مديريت سايت | اين مقاله ۵۹۳۳ بار تاکنون ديده شده است.
۱۳۸۱/۱۱/۱۹ | برای وبلاگ برای وبلاگ
نحوه ارسال نامه در ASP.NET با امکانات و تنظيمات بيشتر با استفاده از CDOSYS.

دقيقا نمی دانم که اين موضوع چقدر برای شما می تواند مهم باشد اما برای من و سايت IranASP.NET که باعث شده بود تا پل ارتباطی با مراجعه کنندگان سايت يعنی همان E-mail و صفحه ارتباط با ما، ثبت نام در راهنمای ASP.NET ايران، ارسال خبرنامه و بالاخره پذيرش اشتراک خبرنامه را از دست بدهيم خيلی مهم بود. در همه قسمتهای فوق نامه يا نامه هايی توسط سايت بصورت خودکار به آدرسی ارسال می شود که حتما شما نحوه ارسال يک نامه را در ASP.NET بخوبی می دانيد. اگر هم نمی دانيد کافی است به کد ساده زير برای ارسال يک نامه نمونه و ساده دقت فرمائيد:

[C#]
MailMessage objMM = new MailMessage();
objMM.From = "me@myhost.com";
objMM.To = "you@yourhost.com";
objMM.Subject = "Welcome!";
objMM.Body = "Welcome to IranASP.NET";
SmtpMail.Send(objMM);

از آنجا که نامه های ارسالی به سايت بصورت روزانه دريافت و خوانده می شوند، يک روز متوجه شدم که به طرز مشکوکی هيچ نامه ای برای سايت ارسال نشده است. به صفحه ارتباط با ما رفته و سعی کردم که نامه ای تستی برای سايت ارسال کنم که با Exception يا خطای زير مواجه شدم:

The "SendUsing" configuration value is invalid.

پس از بررسی های متعدد متوجه شدم که با يک مساله امنيتی و تغييری در تنظيمات سرور مواجه هستم. دليلی که برای اين مشکل پيدا کردم اين بود: احتمالا نصب Service Pack 3 برای Microsoft Exchange Server در سرور مربوطه! اطلاعات دقيق و روشنی هم از host مربوطه نتوانستم بگيرم. آيا اين دليل درست بود يا نه مهم نبود. آنچه که مهم بود اين بود که ديگر نامه های ارسالی از طريق سايت با کد برنامه فوق کار نمی کردند و ارسال نمی شدند. بعبارت ديگر برنامه سايت احتمالا بدليل مسائل امنيتی و محدوديتهای جديد آن ديگر نمی توانست بصورت مستقيما از SMTP Server پيش فرض و موجود در IIS استفاده کرده و از طريق آن نامه ها را ارسال کند. مساله مهمی بود و بايد هرچه زودتر حل می شد.

جستجوها در اينترنت شروع شد و نتايج جالبی هم بدست آمد. حاصل آن بود که بايد از روش ديگری نامه را ارسال کرد. آن روش استفاده از CDOSYS بود بجای CDONTS. ظاهرا اين کامپوننت فقط هم برای ويندوز 2000 می باشد و برای NT چيزی پيدا نکردم. البته کامپوننت CDOEX هم برای استفاده از Exchange هم موجود است.

استفاده از CDOSYS دست شما را برای ارسال يک نامه از طريق برنامه کاملا باز می گذارد و محدوديتهای CDONTS را ديگر نداريد. موارد زير را می توانيد برای ارسال يک نامه و قبل از ارسال آن تعيين نمائيد:

• آدرس SMTP Server بعنوان سرور فرستنده: اين سرور می تواند هر سرور خارجی يا داخلی باشد.
• پورت مورد استفاده جهت ارسال نامه: ديگر مجبور نيستيد همواره از پورت 25 استفاده کنيد.
• username و password برای حالتی که سرور SMTP شما نياز به Authentication دارد.
• محل يا دايرکتوری ذخيره نامه های ارسالی پيش از ارسال: تعيين اين محل در اختيار شماست. سرور فرستنده شما هر وقت فرصت پيدا کند سری به اين محل زده و در صورت وجود نامه ای در آن، نامه يا نامه های موجود و منتظر را ارسال می کند.
نکته: همين مساله سبب می شود تا شما بصورت مستقيم با سرور فرستنده در ارتباط نباشيد. همين مساله احتمالا مشکل سايت IranASP.NET را حل کرد!
• و بسياری موارد ديگر که می توانيد در راهنمای مربوطه مطالعه نمائيد.

ماحصل همه گفتار فوق کد زير است که در سايت IranASP.NET هم اکنون استفاده می شود و بخوبی هم جواب داده است:

[C#]
int cdoSendUsingPickup = 1;
string cdoSendUsingMethod = "http://schemas.microsoft.com/
cdo/configuration/sendusing";
string cdoSMTPServerPickUpDirecory = "http://schemas.microsoft.com/
cdo/configuration/smtpserverpickupdirectory";
// You can uncomment each line when you need it!
//string cdoSMTPServer = "http://schemas.microsoft.com/
cdo/configuration/smtpserver";
//string cdoSMTPServerPort = "http://schemas.microsoft.com/
cdo/configuration/smtpserverport";
//string cdoSMTPConnectionTimeout = "http://schemas.microsoft.com/
cdo/configuration/smtpconnectiontimeout";
//string cdoSMTPAuthenticate = "http://schemas.microsoft.com/
cdo/configuration/smtpauthenticate";
//string cdoSendUserName = "http://schemas.microsoft.com/
cdo/configuration/sendusername";
//string cdoSendPassword = "http://schemas.microsoft.com/
cdo/configuration/sendpassword";

//For CDOSYS, the pickup directory is located at
c:\inetpub\mailroot\pickup
string strPickup = "c:\\inetpub\\mailroot\\pickup";

CDO.Message objMM = new CDO.Message ();
ADODB.Fields Flds = objMM.Configuration.Fields;

Flds[ cdoSendUsingMethod ].Value = cdoSendUsingPickup;
Flds[ cdoSMTPServerPickUpDirecory ].Value = strPickup;

Flds.Update ();
objMM.HTMLBodyPart.Charset = "utf-8";
objMM.MimeFormatted = true;

objMM.From = "me@myhost.com";
objMM.To = "you@yourhost.com";

objMM.Subject = "Welcome!";
objMM.HTMLBody = "<HTML><HEAD></HEAD><BODY><b>Welcome to IranASP.NET!</b></BODY></HTML>";

objMM.Send ();

دقت کنيد چون خواسته ايم که نامه ما احتمالا فارسی باشد لذا از utf-8 و HTMLBody استفاده کرده ايم. همچنين برای اجرای اين برنامه به دو فايل DLL زير هم در شاخه bin سايتتان يا در GAC يا هرجای ديگر هم نياز داريد (من در bin کپی کردم):

• adodb.dll
• Interop.CDO.dll

نگران نباشيد اگر ويندوز 2000 را داريد اين فايلها در کامپيوتر شما موجود است. اين دو فايل بايد در قسمت References در Visual Studio .NET به پروژه سايت شما الصاق شده تا برنامه شما کامپايل شود.

جهت اطلاعات بيشتر به موارد زير رجوع نمائيد:

  1. CDO for Windows 2000
  2. CDO for Win2000: Messaging Configuration
  3. CDO for Win2000: Configuring the Message Object
  4. CDO for Win2000: Creating and Sending a Message
  5. PRB: Microsoft Exchange 2000 Server Service Pack 3 Security Modification and CDOEX/CDOSYS
  6. Sending Email Via an External SMTP Server Using CDO

همه مقالات کليات ASP.NET را ببينيد.
جستجو: بگرد!
جستجوی پيشرفته
نام کاربری |
کلمه عبور |


IranASP.NET - يک کنترل اعتبارسنجی دلخواه برای ListBox

يک کنترل اعتبارسنجی دلخواه برای ListBox

مديريت سايت | اين مقاله ۳۹۰۱ بار تاکنون ديده شده است.
۱۳۸۱/۱۲/۱۷ | برای وبلاگ برای وبلاگ
نحوه ساخت يک کنترل اعتبارسنجی نمونه و دلخواه جهت انتخاب تعداد معينی گزينه از يک ListBox توسط کاربر.

در پياده سازی يک برنامه تحت وب با استفاده از ASP.NET نياز داشتم که کاربر را مجبور کنم که از گزينه های موجود در يک ListBox، حداقل يک مورد را انتخاب کند. بديهی است که اين کار با استفاده از يک کنترل استاندارد و موجود در ASP.NET بنام RequiredFieldValidator براحتی قابل انجام است. کافی است صفت ControlToValidate مربوط به اين کنترل اعتبارسنجی را مطابق نام ListBox خود قرار دهيد و همين!

اما چند سوال: اگر خواستيد کاربر را مجبور به انتخاب دو گزينه يا بيشتر نمائيد چطور؟ يا اگر خواستيد کنترل بيشتری بر ورودی صفحه تان داشته باشيد يا بعبارت ديگر بعنوان يک برنامه نويس حرفه ای ASP.NET، مانور بيشتری در اين زمينه داشته باشيد؟ يا شايد اصلا نياز داشتيد که کنترل های اعتبارسنجی خاصی را مطابق نيازتان داشته باشيد که تاکنون نوشته نشده باشند؟

در اين مقاله کوتاه سعی شده است تا جواب همه سوالات فوق با ارائه يک کنترل اعتبارسنجی نمونه و آموزشی داده شود. اين کنترل سعی دارد که اندکی بيشتر از رفتار کنترل اعتبارسنجی معروف RequiredFieldValidator را شبيه سازی نمايد و شما با ياد گرفتن اصول بکار رفته در آن می توانيد آن را توسعه داده يا کنترلهای اعتبارسنجی متنوع ديگری را به کتابخانه کنترلهای خود اضافه نمائيد.

قبل از پرداختن به برنامه مذکور دقت داشته باشيد که اين کنترل دارای محدوديتها و ويژگيهای زير می باشد:

• اين کنترل از کلاس استاندارد BaseValidator مشتق (به ارث) گرفته شده است.
• در اين برنامه فقط به اعتبارسنجی سمت کاربر يا اصطلاحا Client Side پرداخته شده است.
• جهت انجام اعتبارسنجی سمت سرور يا Server Side نياز است که متد مربوطه را خودتان بنويسيد و به آن اضافه کنيد.
• با استفاده از مقداردهی صفت RequieredItem مربوط به اين کنترل می توانيد تعداد گزينه هايی که بايد توسط کاربر حتما انتخاب شود را تعيين کنيد(دقت داشته باشيد که برای حالت بيش از يک گزينه لازم است که صفت SelectionMode مربوط به ListBox شما قبلا مطابق مقدار Multiple تنظيم شده باشد).
• می توانيد از اين کنترل احتمالا با اعمال تغييرات کوچکی برای ساير کنترلها مانند DropDownList ،CheckBoxList يا RadioButtonList نيز استفاده کنيد.

خوب فکر کنم حرف زدن کافی است و زودتر برويم سراغ اصل مطلب:

[C#]
using System;
using System.Text;
using System.Web.UI;
using System.Web.UI.WebControls;

namespace MyLib
{
/// <summary>
/// Summary description for RequieredListBoxValidator.
/// </summary>
public class RequieredListBoxValidator : BaseValidator
{
protected int _RequieredItem = 1;

public int RequieredItem
{
get
{
return this._RequieredItem;
}
set
{
this._RequieredItem = value;
}
}

protected override bool ControlPropertiesValid()
{
return true;
}

protected override bool EvaluateIsValid()
{
return this.EvaluateHasItem();
}

protected bool EvaluateHasItem()
{
ListBox _lstb = ( ( ListBox ) this.FindControl( this.ControlToValidate ) );
return (_lstb.Items.Count != 0);
}

protected override void OnPreRender( EventArgs e )
{
if ( this.EnableClientScript ) { this.ClientScript(); }
base.OnPreRender( e );
}

protected void ClientScript()
{
this.Attributes["evaluationfunction"] = "lb_verify";

StringBuilder sb_Script = new StringBuilder();
sb_Script.Append( "<script language=\"javascript\">" );
sb_Script.Append( "\r" );
sb_Script.Append( "\r" );
sb_Script.Append( "function lb_verify(val) {" );
sb_Script.Append( "\r" );
sb_Script.Append( "var val = document.all[document.all[\"" );
sb_Script.Append( this.ClientID );
sb_Script.Append( "\"].controltovalidate];" );
sb_Script.Append( "\r" );
sb_Script.Append( "if ( val != null ) {" );
sb_Script.Append( "\r" );
sb_Script.Append( "if (val.tagName == \"SELECT\") {" );
sb_Script.Append( "\r" );
sb_Script.Append( "var selCount = 0;\r" );
sb_Script.Append( "var i;\r" );
sb_Script.Append( "for(i=0;i<val.options.length;i++)\r" );
sb_Script.Append( "{\r" );
sb_Script.Append( "if(val.options[i].selected)\r" );
sb_Script.Append( "selCount++;\r" );
sb_Script.Append( "}\r" );
sb_Script.Append( "if ( selCount >= "
+ this._RequieredItem.ToString () + " ) {" );
sb_Script.Append( "\r" );
sb_Script.Append( "return true;" );
sb_Script.Append( "\r" );
sb_Script.Append( "}" );
sb_Script.Append( "\r" );
sb_Script.Append( "}" );
sb_Script.Append( "\r" );
sb_Script.Append( "\r" );
sb_Script.Append( "return false;" );
sb_Script.Append( "\r" );
sb_Script.Append( "}" );
sb_Script.Append( "\r" );
sb_Script.Append( "}" );
sb_Script.Append( "\r" );
sb_Script.Append( "</script>" );
this.Page.RegisterClientScriptBlock( "LSBScript", sb_Script.ToString() );
}
}
}

کلاس فوق را در قالب يک Assembly (يا همان DLL خودمان اما از نوع دات نت) کامپايل کنيد و DLL بدست آمده را در قسمت References برنامه استفاده کننده از اين کنترل در VS.NET به برنامه خود الصاق نمائيد. حال جهت استفاده از اين کنترل مطابق زير عمل کنيد.

<%@ Page language="c#" Codebehind="WebForm1.aspx.cs" AutoEventWireup="false" Inherits="WebApplication1.WebForm1" %>
<%@ Register TagPrefix="mylib" Namespace="MyLib" Assembly="MyLib" %>
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN" >
<HTML>
<HEAD>
<title>WebForm1</title>
<meta name="GENERATOR" Content="Microsoft Visual Studio 7.0">
<meta name="CODE_LANGUAGE" Content="C#">
<meta name="vs_defaultClientScript" content="JavaScript">
<meta name="vs_targetSchema" content="http://schemas.microsoft.com/intellisense/ie5">
</HEAD>
<body MS_POSITIONING="FlowLayout">
<form id="WebForm1" method="post" runat="server">
<asp:ListBox id="ListBox1" runat="server" SelectionMode="Multiple">
<asp:ListItem Value="1">Item 1</asp:ListItem>
<asp:ListItem Value="2">Item 2</asp:ListItem>
<asp:ListItem Value="3">Item 3</asp:ListItem>
</asp:ListBox>
<mylib:RequieredListBoxValidator id="RequieredListBoxValidator1" runat="server" RequieredItem="2" ErrorMessage="You have to select at least 2 items from list box!" ControlToValidate="ListBox1"></mylib:RequieredListBoxValidator>
<br>
<asp:Button id="Button1" runat="server" Text="Button"></asp:Button>
</form>
</body>
</HTML>

همه مقالات فرم های وب را ببينيد.
جستجو: بگرد!
جستجوی پيشرفته
نام کاربری |
کلمه عبور |


IranASP.NET - ListBox با گزينه های رنگی در ASP.NET

ListBox با گزينه های رنگی در ASP.NET

مديريت سايت | اين مقاله ۵۱۹۰ بار تاکنون ديده شده است.
۱۳۸۲/۱/۲۱ | برای وبلاگ برای وبلاگ دريافت کد
در اين مقاله نحوه نوشتن يک listbox دلخواه با قابليت تعيين موارد Style برای گزينه های آن بصورت جداگانه ارائه شده است.

در اين مقاله آموزشی سعی خواهد شد تا نحوه ساخت و برنامه نويسی کنترلهای دلخواه در ASP.NET نشان داده شود. اين کار با در نظر گرفتن طراحی يک ListBox خاص که دارای اين قابليت هست که بتوان رنگ متن و پس زمينه برخی از گزينه های آن را به دلخواه تعيين کرد، انجام می گردد.

کاربرد چنين کنترلی بسته به نياز و سليقه شما می تواند متفاوت باشد. مثلا ممکن است در برنامه ای بخواهيد گزينه های مرتبط با هم را دسته بندی کرده و هر دسته را با رنگ پس زمينه خاصی نشان دهيد. اين مساله می تواند در تشخيص يا يافتن سريعتر گزينه های خاصی به کاربر کمک کند.

شايد اين سوال برای شما پيش آيد که چه احتياجی به نوشتن يک کنترل ListBox جديد است و مثلا می توان مانند زير عمل کرد:

ListItem item;
for(int i = 1; i<=10; i++)
{
item = new ListItem ();
item.Value = i.ToString ();
item.Text = "Item" + i.ToString ();
item.Attributes.Add ("Style", "background-color: #0000ff;color: #ffffff");
myListBox.Items.Add (item);
}

اما نکته جالب اينجاست که کد برنامه فوق کار نمی کند! بعبارت ديگر صفت Style برای کلاس ListItem در زمان توليد کد HTML اصطلاحا render نمی شود و به آن ترتيب اثری داده نمی شود. شايد اين مساله در نسخه های بعدی ASP.NET رفع شود يا اينکه اصولا اين رفتار برای کنترل ListBox براساس طرح آن درست باشد.

بهرحال اين مساله به هر شکلی که تعبير شود برای ما بهانه خوبی است که اصولا نحوه نوشتن کنترلهای دلخواه و پيشرفته تر را بطور کلی ياد بگيريم و توان و مهارت خود را در اين زمينه افزايش دهيم. دقت داشته باشيد که يک برنامه نويس حرفه ای ASP.NET نمی تواند مصرف کننده صرف کنترلهای استاندارد يا از پيش تهيه شده توسط ديگران باشد، بلکه لازم است که او خود هم گاهی وقتها آستين را بالا زده و به اين جمع بپيوندد و کنترلهای خاص مورد نياز خود يا ديگران را توليد کند.

به جهت اينکه قطعه برنامه فوق کار کند و منظور ما را برآورده سازد لازم است که اندکی در کار ListBox استاندارد ASP.NET دخالت کرده و کد render آن را دستکاری کنيم. خيالتان راحت باشد ما هيچگونه دسترسی به سورس ListBox نداريم! تنها کافی است اندکی ابتکار شئ گرايی خود را به کار انداخته و اين کار را با استفاده از مفهوم وراثت يا Inheritance انجام دهيم. (خدا را شکر که دات نت شئ گراست!)

بدين منظور يک کلاس جديد به نام StyledListBox تعريف می کنيم و اين کلاس را از کلاس اصلی و استاندارد ListBox به ارث می گيريم. قطعه کد زير چگونگی اين کار را با استفاده از زبان #C به شما نشان می دهد:

[C#]
using System;
using System.Collections;
using System.Web.UI;
using System.Web.UI.WebControls;

namespace ColoredListBox
{
/// <summary>
/// Summary description for StyledListBox.
/// </summary>
public class StyledListBox : System.Web.UI.WebControls.ListBox
{
}
}

می بينيد که اين کار چقدر ساده است. ColoredListBox نام فضانام يا نامکده ما است و شما می توانيد نام دلخواه خود را استفاده کنيد. نام کلاس جديد ما StyledListBox است که بصورت public تعريف شده است تا همگان بتوانند از آن استفاده کنند. پدر کلاس ما اينجا همان ListBox استاندارد ASP.NET يعنی System.Web.UI.WebControls.ListBox می باشد و ما با اين کار کليه ويژگيها و متدهای ListBox را مال خود کرده ايم.

بدنه اين کلاس خالی است و دارائی های ListBox برای هدف ما کافی نيستند و قابليتهای ديگری را نيز می خواهيم. بعبارت ديگر در دارائی های ListBox منظور نشده است که گزينه ها را برای ما رنگی کند و خود ما بايد اين ويژگی را به قدرت و توان ListBox اضافه کنيم.

برای اين کار تنها کافيست متد RenderContents مربوط به ListBox را بازنويسی کنيم. در زير شکل کامل اين کلاس را می بينيم:

[C#]
using System;
using System.Collections;
using System.Web.UI;
using System.Web.UI.WebControls;

namespace ColoredListBox
{
/// <summary>
/// Summary description for StyledListBox.
/// </summary>
public class StyledListBox: System.Web.UI.WebControls.ListBox
{
override protected void RenderContents(HtmlTextWriter writer)
{
for(int c=0;c<Items.Count;c++)
{
ListItem i = Items[c];
writer.WriteBeginTag("option");
if(i.Selected)
writer.WriteAttribute("selected","selected",false);
writer.WriteAttribute("value",i.Value,true);
IEnumerator d = Items[c].Attributes.Keys.GetEnumerator();
while(d.MoveNext())
writer.WriteAttribute(d.Current.ToString(),Items[c].Attributes[d.Current.ToString()]);
writer.Write('>');
System.Web.HttpUtility.HtmlEncode(i.Text,writer);
writer.WriteEndTag("option");
writer.WriteLine();
}
}
}
}

از قيافه کد برنامه فوق نترسيد! اگر اندکی با کلاس HtmlTextWriter بيشتر آشنا شويد خواهيد ديد که اين متد چقدر ساده و در عين حال جالب است. عمده کاری که در اين متد انجام شده است اين است که علاوه بر صفتهای استاندارد گزينه های يک listbox مانند value و selected، سعی کرده ايم تا کليه صفات يا Attributeهای آن را هم در کد HTML بنويسيم، کاری را که ظاهرا خودِ ListBox نکرده يا نخواسته يا حداقل ما آن را نمی دانيم! اين کار با دو خط زير انجام شده است:

[C#]
IEnumerator d = Items[c].Attributes.Keys.GetEnumerator();
while(d.MoveNext())
writer.WriteAttribute(d.Current.ToString(),Items[c].Attributes[d.Current.ToString()]);

حالا وقت آن است که نحوه کاربرد اين کلاس را هم بيان کنيم. جهت اين کار کافی است همانند ListBox معمولی عمل کرده منتها listbox خود را از نوع ColoredListBox.StyledListBox تعريف کرده و رنگ دلخواه خود را برای گزينه های مختلف تعريف کنيم. به فايل codebehind زير توجه فرمائيد.

[C#]
using System;
using System.Collections;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Web;
using System.Web.SessionState;
using System.Web.UI;
using System.Web.UI.WebControls;
using System.Web.UI.HtmlControls;

namespace ColoredListBox
{
/// <summary>
/// Summary description for WebForm1.
/// </summary>
public class WebForm1 : System.Web.UI.Page
{
protected StyledListBox ListBox1;

private void Page_Load(object sender, System.EventArgs e)
{
// Put user code to initialize the page here
ListItem item;

item = new ListItem ("IranASP.NET 1", "1");
item.Attributes.Add ("Style", "background-color:#39B54A; color:#ffffff");
this.ListBox1.Items.Add (item);

item = new ListItem ("IranASP.NET 2", "2");
item.Attributes.Add ("Style", "color:#0000ff");
this.ListBox1.Items.Add (item);

item = new ListItem ("IranASP.NET 3", "3");
item.Attributes.Add ("Style", "background-color:#ff0000; color:#ffffff");
this.ListBox1.Items.Add (item);
}
}
}

تنها يک کار ديگر باقی مانده است و آن تغيير کد فايل aspx در مورد نحوه تعريف کنترل listbox مورد نظر است. ابتدا بايد خط زير را در بالای فايل مذکور قرار دهيد تا بدين ترتيب کلاس StyledListBox ما برای اين فايل قابل دسترس باشد:

<%@ Register TagPrefix="iranasp" Namespace="ColoredListBox" Assembly="ColoredListBox" %>

در اينجا همانند تعريف يک کنترل کاربری يا User Control عمل کرده ايم. حال listbox خود را بصورت زير تعريف می کنيم:

<iranasp:StyledListBox id="ListBox1" runat="server"></iranasp:StyledListBox>

و همين!

نکته: اگر دقت کرده باشيد علاوه بر رنگ می توان هر نوع صفت موجود در خصيصه Style را برای گزينه های اين listbox تعريف نمود.

همه مقالات فرم های وب را ببينيد.
جستجو: بگرد!
جستجوی پيشرفته
نام کاربری |
کلمه عبور |


IranASP.NET - ۱۰ دليل مهم جهت ارتقاء به Visual Studio .NET 2003

۱۰ دليل مهم جهت ارتقاء به Visual Studio .NET 2003

مديريت سايت | اين مقاله ۴۸۸۱ بار تاکنون ديده شده است.
۱۳۸۲/۲/۲ | برای وبلاگ برای وبلاگ
Visual Studio .NET 2003 نسبت به نسخه قبلی خود دارای امکانات و قابليتهای بيشتری می باشد که امر توليد انواع برنامه و سيستم ها را ارتقاء بخشيده است.

۱- امکان توليد برنامه های قابل اجرا برروی دستگاههای موبايل
با استفاده از VS .NET 2003 می توانيد برنامه های قابل اجرا برای دستگاههای موبايل مانند Pockect PC ،Tablet PC و تلفن های موبايل را به آسانی توليد کنيد. اين برنامه ها را می توانيد با Microsoft Visual Basic .NET 2003 يا Microsoft Visual C# .NET 2003 بسازيد.

۲- از آخرين نسخه دات نت استفاده کنيد
با استفاده از NET Framework 1.1. يک دات نت کامل تر را خواهيد داشت که از لحاظ امنيت و کارآيی نسبت به نسخه قبل بسيار بهتر شده است.

۳- جادوگر قويتر!
جادوگر يا همان Wizard محبوب برای تبديل برنامه های Visual Basic 6.0 به Visual Basic .NET اکنون بسيار بهتر و قويتر شده است و از User Controls و کلاسهای وب پشتيبانی می کند.

۴- بهشت برنامه نويسان Java!
با دارا بودن Visual J# .NET در VS .NET 2003 برنامه نويسان علاقمند به زبان Java می توانند برنامه ها و سرويس های وب خود را به زبان Java با استفاده از دات نت توليد کنند.

۵- Enterprise Instrumentation Framework يا EIF
VS .NET 2003 با ارائه ابزار Enterprise Instrumentation Framework شما را قادر می سازد تا به آسانی قابليت های ديده بانی (monitoring) را برای زمان اجرا (run-time) به هر برنامه ای اضافه نمائيد.

۶- پشتيبانی از سرويس های XML وب
VS .NET 2003 علاوه بر ارتقاء پشتيبانی خود از سرويس های XML وب، از آخرين استانداردهای سرويس های وب شامل WS-Routing ،WS-Security ،WS-Attachments و DIME حمايت می کند.

۷- ديباگر بهتر شده
يک ديباگر (debugger) بهتر شده ديد بهتری از داده ها و اطلاعات برنامه به شما داده و به شما کمک می کند تا اشکالات و خطاهای برنامه را بهتر يافته و رفع کنيد.

۸- ADO.NET جديد
يک تامين داده (Data Provider) جديد ADO.NET که امکان ارتباط با بانکهای اطلاعاتی Oracle 8i ،Oracle 7i و منبع داده ODBC را به مجموعه قبلی خود افزوده است.

۹- سايتهای online انجمن دات نت
علاوه بر يک سيستم پويای يکپارچه بهتر شده Help، می توانيد از سايتهای انجمن دات نت بصورت online راهنمائی و کمک بگيريد.

۱۰- محيط توليد يکپارچه (IDE) جديد
محيط برنامه نويسی VS. NET 2003 نسبت به نسخه قبلی آن بسيار بهتر شده است و قابليت و امکانات بهتر و هوشمندتری را ارائه نموده است که کار برنامه نويسان را برای نوشتن کد برنامه آسانتر می کند.

منبع: Top 10 Reasons to Upgrade to Visual Studio .NET 2003

همه مقالات کليات ASP.NET را ببينيد.
جستجو: بگرد!
جستجوی پيشرفته
نام کاربری |
کلمه عبور |


IranASP.NET - JavaScript و ASP.NET

JavaScript و ASP.NET

مديريت سايت | اين مقاله ۶۵۴۹ بار تاکنون ديده شده است.
۱۳۸۲/۳/۱۲ | برای وبلاگ برای وبلاگ
اين مقاله به بررسی ارتباط ميان کدهای Server-Side و Client-Side پرداخته و نحوه برقراری اين ارتباط را با ذکر چند مثال کاربردی شرح می دهد.

معمولاً با مشاهده عبارت ASP.NET مفهوم Server-Side (سمت سرور) در ذهن برنامه نويسان وب تداعی می شود. در مقابل، عبارت JavaScript احساس Client-Server (سمت کاربر) را برمی‎انگيزد و هر دو اين تداعی کاملا درست است. اما شايد اين تلقی ايجاد شود که بدليل حوزه فعاليت هر يک پس اين دو به يکديگر اصولاً کاری ندارند! و هرکدام راه خود را می روند و ارتباطی بين اين دو نيست. شايد می توانستيم بجای JavaScript بگوئيم JScript اما از آنجا که JavaScript بين اهالی وب رايج تر و شناخته شده تر است از آن جهت JavaScript را برای بحث خود برگزيده ايم. اما بحث ما بطور کلی در مورد کد برنامه سمت سرور و کد برنامه سمت کاربر است.

اما جالب است که بدانيد ارتباط بسيار خوبی ميان مفهوم Server-Side و Client-Side در ASP.NET وجود دارد. بعبارت ديگر بدون برقراری اين پيوند عملا ASP.NET بسيار ناتوان بود. باز هم از نقطه نظر ديگر اتفاقا همين ارتباط قوی سبب افزايش کارآئی، توان و قدرت ASP.NET شده است بگونه ای که ASP.NET در پياده سازی مفاهيم و امکانات قدرتمند خود بخوبی از کد سمت کاربر بهره برده است. شايد ذکر مختصر يکی دو مثال موضوع را برای شما روشن تر کند.

برای اولين مثال می توان مساله ارسال فرم يا همان Submit را عنوان کرد. همه فرم ها در ASP.NET توسط يک تابع سمت کاربر به زبان JavaScript و بنام doPostBack__ ارسال می شوند. همين الان در مرورگر خود کد HTML همين صفحه را ببينيد و تابع مذکور را در اوايل اين کد پيدا کنيد. اين تابع بصورت runtime هنگامی که اين صفحه ابتدا بر روی سرور ايجاد يا اصطلاحا Render می شد به کد HTML اين صفحه اضافه شده است.

برای مثال دوم می توان به موضوع اعتبارسنجی در ASP.NET و بهره گيری فراوان آن از کد سمت کاربر اشاره نمود. اگر با مقوله اعتبارسنجی در ASP.NET آشنا نيستيد می توانيد مقاله کنترلهای اعتبارسنجی در ASP.NET را مطالعه بفرمائيد. اگر در سايت خود از کنترلهای اعتبارسنجی استفاده کرده باشيد حتما متوجه وجود يک شاخه بنام aspnet_client شده ايد که شما آن را نساخته ايد. در شاخه های تودرتوی اين شاخه نهايتا به سه عدد فايل محتوی کدهای JScript خواهيد رسيد که همان کدهای مورد نياز ASP.NET برای انجام امور مختلف از جمله مساله اعتبارسنجی فرم ها در سمت کاربر می باشند.

شايد با ذکر اين دو مثال ساده به اهميت کدهای سمت کاربر و رابطه خوبی که ASP.NET با آن دارد پی برده باشيد. در اين مقاله قصد دارم شما را بيشتر با اين ارتباط آشنا کنم و به شما نشان دهم که ASP.NET چه امکانات و ابزاری جهت برقراری و توسعه دلخواه اين ارتباط دارد و اينکه شما چگونه می توانيد کد برنامه سمت کاربر دلخواه خود را به صفحاتتان اضافه نموده و مانور بيشتری بدهيد.

متدهای کلاس Page برای کدهای سمت کاربر

کلاس Page که در اصل همه فرم ها و صفحات ما در ASP.NET از آن مشتق می شوند دارای چند متد (Method) بسيار جالب و کاربردی در ارتباط با کدهای اسکريپت سمت کاربر می باشد.

RegisterClientScriptBlock: با استفاده از اين متد می توان هر نوع کد JavaScript دلخواهی را جهت اجرا به صفحه مورد نظر افزود. اين متد داری دو پارامتر از نوع رشته ای (string) بنام های key و script می باشد. پارامتر script همان کد JavaScript مورد نظر ماست و پارامتر key هم يک نام دلخواه ولی منحصر بفرد است که جهت شناسائی اين اسکريپت تعيين می کنيم. اسکريپت مورد نظر شما دقيقاً پس از تگ آغازين <form> در کد HTML صفحه قرار خواهد گرفت. دقت داشته باشيد که اسکريپت مورد نظر شما بايد کامل باشد چرا که ASP.NET هيچ پردازشی برروی آن انجام نخواهد داد و چيزی را به آن اضافه نخواهد کرد. بعبارت ديگر لازم است تگ های مورد نياز يک اسکريپت JavaScrip بهمراه تگ های توضيح (comment) در HTML را مانند مثال زير قبلا به کد خود افزوده باشيد.

<script language="JavaScript">
<!--
کد اسکريپت مورد نظر شما
// -->
</script>

به مثال زير توجه فرمائيد.

[C#]
<html>
<head>
<script language="C#" runat="server">

public void Page_Load(Object sender, EventArgs e) {

// Form the script that is to be registered at client side.
String scriptString = "<script language=JavaScript> function DoClick() {";
scriptString += "myForm.show.value='Welcome to Microsoft .NET'}<";
scriptString += "/";
scriptString += "script>";

if(!this.IsClientScriptBlockRegistered("clientScript"))
this.RegisterClientScriptBlock("clientScript", scriptString);
}

</script>
</head>
<body topmargin="20" leftmargin="10">
<form id="myForm" runat="server">
<input type="text" id="show" style="width=200"> <input type="button" value="ClickMe" onclick="DoClick()">
</form>
</body>
</html>

IsClientScriptBlockRegistered: همانگونه که در مثال قبل ديد اين متد تعيين می کند که آيا اسکريپتی با کليد شناسائی (key) مورد نظر قبلاً توسط متد RegisterClientScriptBlock به صفحه افزوده شده است يا نه. بکارگيری اين متد قبل از فراخوانی متد RegisterClientScriptBlock سبب می شود تا از تکرار يک اسکريپت در يک صفحه جلوگيری شده و منابع موجود در سرور به هدر نرود.

RegisterStartupScript: دقيقا همانند RegisterClientScriptBlock می باشد با اين تفاوت که اسکريپت شما دقيقا قبل از تگ پايانی <form/> قرار خواهد گرفت. به مثال زير توجه فرمائيد.

[C#]
<html>
<head>
<script language="C#" runat="server">
public void Page_Load(Object sender, EventArgs e) {
// Form the script to be registered at client side.
String scriptString = "<script language=JavaScript> function DoClick() {";
scriptString += "showMessage2.innerHTML='<h4>Welcome to Microsoft .NET!</h4>'}";
scriptString += "function Page_Load(){ showMessage1.innerHTML=";
scriptString += "'<h4>RegisterStartupScript Example</h4>'}<";
scriptString += "/";
scriptString += "script>";

if(!this.IsStartupScriptRegistered("Startup"))
this.RegisterStartupScript("Startup", scriptString);
}

</script>
</head>
<body topmargin="20" leftmargin="10" onload="Page_Load()">
<form id="myForm" runat="server">
<span id="showMessage1"></span>
<br>
<input type="button" value="ClickMe" onclick="DoClick()">
<br>
<span id="showMessage2"></span>
</form>
</body>
</html>

IsStartupScriptRegistered: همانگونه که در مثال قبل ديد اين متد تعيين می کند که آيا اسکريپتی با کليد شناسائی (key) مورد نظر قبلاً توسط متد RegisterStartupScript به صفحه افزوده شده است يا نه. بکارگيری اين متد قبل از فراخوانی متد RegisterStartupScript سبب می شود تا از تکرار يک اسکريپت در يک صفحه جلوگيری شده و منابع موجود در سرور به هدر نرود.

GetPostBackClientEvent: با فراخوانی اين متد می توان به نام تابع سمت کاربری که سبب ارسال (Submit) فرم شده است دست يافت.

GetPostBackEventReference: همانند متد GetPostBackClientEvent با فراخوانی اين متد می توان به نام تابع سمت کاربری که سبب ارسال (Submit) فرم شده است دست يافت.

GetPostBackClientHyperlink: با فراخوانی اين متد می توان به نام تابع سمت کاربری که سبب ارسال (Submit) فرم شده است و در حاليکه عبارت :javascript به ابتدای آن افزوده شده است، دست يافت.

RegisterOnSubmitStatement: با استفاده از اين متد می توان به رويداد OnSubmit مربوط به فرم موجود در صفحه دسترسی داشت و کد مورد نظر خود را به آن افزود. به مثال زير توجه فرمائيد.

[C#]
void Page_Load(Object sender, EventArgs e)
{
String scriptString = "<script language=JavaScript> function doClick() {";
scriptString += "document.write('<h4>' + myForm.myHiddenField.value+ '</h4>');}<";
scriptString += "/" + "script>";

RegisterHiddenField("myHiddenField", "Welcome to Microsoft .NET!");

RegisterOnSubmitStatement("submit", "document.write('<h4>Submit button clicked.</h4>')");

RegisterStartupScript("startup", scriptString);
}

يک کلاس کوچک و ساده ولی کاربردی

در ادامه کلاس نمونه ای ارائه شده است که ممکن است برای برنامه های شما مفيد باشد. متدهای موجود در اين کلاس کارهای خيلی ساده ای را انجام می دهند اما استفاده از آنها سبب راحتی کار برنامه نويسی، مديريت آسان برنامه و افزايش قابليت خواندن کد برنامه می شود. توجه داشته باشيد که متدهای اين کلاس همگی بصورت static تعريف شده اند و برای استفاده از آنها نيازی به تعريف و ايجاد آبجکت مربوطه نداريد (نيازی به استفاده از عملگر new و تعريف متغير از اين نوع کلاس نداريد). در عوض بايد نام نامکده (namespace) و نام کلاس را قبل از نام متد بياوريد (Common.PageUtil.MakeJavaScriptBlock). شما هم می توانيد متدهای کاربردی دلخواه خود را به اين کلاس نمونه اضافه نمائيد.

using System;
using System.Web.UI;
using System.Text;
using System.Web.UI.WebControls;

namespace Common
{
/// <summary>
/// Utility class for ASP.NET pages
///
/// Be sure to notice that this code is provided as a technology sample
/// and 'as is' and no warranties are made by the author.
///
/// </summary>
public class PageUtil
{
// This static methods helps you build your JavaScript blocks easily
public static string MakeJavaScriptBlock(string strJavascript)
{
string sScript;
sScript = "\n<script language=\"javascript\">\n";
sScript += "<!--\n";
sScript += strJavascript;
sScript += "// -->\n";
sScript += "</script>\n";
return sScript;
}

// This staic method is used in popup screens
// to close popup after doing some thing
public static void CloseCurrent(System.Web.UI.Page page)
{
string sScript = "window.close();";
sScript = Common.PageUtil.MakeJavaScriptBlock (sScript);
page.RegisterStartupScript ("CloseCurrent", sScript);
}

public static void ShowAlert(string msg, System.Web.UI.Page page)
{
if (page.Request.Browser.JavaScript == true)
{
string sScript = "alert(\"" + msg + "\");\n";
sScript = Common.PageUtil.MakeJavaScriptBlock (sScript);
page.RegisterStartupScript ("ShowAlertScript", sScript);
}
}
}
}

همه مقالات فرم های وب را ببينيد.
جستجو: بگرد!
جستجوی پيشرفته
نام کاربری |
کلمه عبور |


IranASP.NET - برنامه نويسی بهتر با Typed DataSet - قسمت اول

برنامه نويسی بهتر با Typed DataSet - قسمت اول

مديريت سايت | اين مقاله ۵۳۴۰ بار تاکنون ديده شده است.
۱۳۸۲/۴/۷ | برای وبلاگ برای وبلاگ
استفاده از Typed DataSet سبب می شود تا ضمن نوشتن برنامه ای جامع تر و کارآمدتر، قابليت خواندن آن را افزايش داده و نسبت به اجرای آن اطمينان داشته باشيم.

در اين مقاله برآنيم تا شما را با يکی از قويترين و کارآمدترين روشهای کار با DataSetها آشنا کنيم. بعبارت ديگر می خواهيم شما را با نوع جديدی از DataSet يعنی Typed DataSet آشنا کنيم و نحوه ايجاد، بکارگيری و فوايد آن را با هم ببينيم. بنابراين لازم است که شما قبلا با DataSet و کاربردهای آن آشنا بوده و يا با آن کار کرده باشيد. استفاده از Typed DataSet سبب می شود تا برنامه های شما جامع تر و بهتر شده و نيز از طرف ديگر برنامه شما اصطلاحاً type safety می شود.

در اين مقاله شما احتمالا به ابزارهای زير نياز داريد:

• Visual Studio.NET
• Windows 2000
• Visual C#
• SQL Server 2000

فراموش نکنيد که فرض اين مقاله بر اين است که شما با ADO.NET DataSet و مفاهيم مربوط به آن کاملاً آشنا هستيد.

Typed DataSet برعکس DataSet، مجموعه ای از کلاس های استاندارد NET Framework. نيست بلکه عبارت است از مجموعه کلاس هايی که به کمک ابزارهايی در NET Framework. توسط برنامه نويس توليد می شود و علاوه بر خواص و قابليتهای موجود در DataSet، دارای متدها، رويداد(event)ها و صفات اضافه و مختص به خود می باشد.

واضح است که Typed DataSet برای اينکه تمامی خواص و ويژگيهای DataSet را داشته باشد لازم است که از DataSet مشتق يا به ارث گرفته شده باشد و همينگونه نيز می باشد. بنابراين Typed DataSet کلاسی است که از DataSet به ارث گرفته شده است و دارای صفات و متدهای اضافه تری جهت برآورده کردن اهداف مورد نظر می باشد.

يکی از اين اهداف دسترسی آسان و مطمئن به جداول (table) و فيلدهای داده ای با استفاده از نام آنها می باشد. در DataSet معمولی شما مجبور هستيد که از متدهای اصطلاحاً collection-based و انديس های تودرتو برای دستيابی به جداول و محتويات آنها استفاده کنيد. همانگونه که می دانيد اکثر اين انديس ها متنی می باشند و اشتباهات تايپی شما تنها در زمان اجرا نمايان خواهند شد و اين مساله می تواند برای شما آزار دهنده بوده و يا باعث ايجاد خطاهای منطقی شود که رفع آنها ممکن است ساعتها وقت شما را بخود اختصاص دهد.

علاوه بر قابليت خواندن بالايی که Typed DataSet به کد برنامه شما می دهد، استفاده از Typed DataSet سبب می شود تا بتوانيد از امکان Intellisense محيط ويرايشگر Visual Studio .NET بهره برده و کد برنامه شما راحتتر و سريعتر تايپ شود. همچنين Typed DataSet اين امکان را برای شما فراهم می سازد تا کامپايلر مورد استفاده تان نوع فيلدها را در زمان کامپايل تشخيص داده و در صورت نسبت دادن مقادير با تايپ های مختلف به يکديگر، خطای لازم را اعلام نمايد. دقت داشته باشيد که اينکار در زمان کامپايل صورت می گيرد و نه در زمان اجرا و اين چيزی نيست جز دسترسی type-safe به DataSet و در نتيجه افزايش قابليت اطمينان برنامه شما! به همين دليل است که به اين نوع DataSet اصطلاحاً Typed DataSet می گوئيم.

تفاوت DataSet و Typed DataSet

تفاوتهای زيادی از لحاظ شکل نوشتن برنامه گرفته تا کارآيی بين اين دو وجود دارد. در اين قسمت اين تفاوتها را از لحاظ type-safety و شکل ظاهری با ذکر دو مثال بررسی می کنيم.

در کد برنامه زير از DataSet معمولی استفاده شده است:

String connectionString = "server=localhost;Trusted_Connection=yes;database=Northwind";

SqlConnection conn = new SqlConnection(connectionString);

SqlDataAdapter EmployeesDA = new SqlDataAdapter("SELECT * FROM EMPLOYEES;", conn);

DataSet ds = new DataSet();

EmployeesDA.Fill(ds, "Employees");

//Name of the table is misspelled to Employes
//instead Employees, which is wrong
// در اينجا نام جدول عمدا اشتباه تايپ شده است
Console.WriteLine(ds.Tables["Employes"].Rows[0]["FirstName"]);

//LastName contains one space at the end, which is wrong
// در اينجا عمدا يک فضای خالی بعد از Lastname آورده شده است
Console.WriteLine(ds.Tables["Employees "].Rows[0]["LastName "]);

//this is wrong because ReportsTo must be an employeeID,
//an integer value
// در اينجا اشتباها يک مقدار رشته حرفی به يک متغير عددی نسبت داده شده است
ds.Tables["Employees"].Rows[0]["ReportsTo"] = "Paul";

می بينيد که در کد برنامه بالا مجبور هستيم که از نام جدول و فيلدها بعنوان انديس استفاده کنيم که احتمال اشتباه تايپی در آن بسيار زياد است و ما به عمد اين اشتباهات را انجام داده ايم. همچنين به عمد يک رشته حرفی را به متغيری از نوع عددی منسوب نموده ايم. هيچيک از اين اشتباهات در زمان کامپايل برنامه تشخيص داده نخواهد شد در عوض اين اشتباهات در زمان اجرای برنامه خود را بصورت خطای زمان اجرا نشان خواهند داد که بهيچ عنوان مطلوب و پذيرفته نيست.

در کد برنامه زير از Typed DataSet استفاده شده است:

String connectionString = "server=localhost;Trusted_Connection=yes;database=Northwind";

SqlConnection conn = new SqlConnection(connectionString);

SqlDataAdapter EmployeesDA = new SqlDataAdapter("SELECT * FROM EMPLOYEES", conn);

//Creating an Instance of Typed DataSet "EmployeesTDS"
EmployeesTDS ds = new EmployeesTDS();

EmployeesDA.Fill(ds, "Employees");

Console.WriteLine(ds.Employees[0].FirstName);
Console.WriteLine(ds.Employees[0].LastName);

//this is wrong because ReportsTo must be an employeeID,
//an integer value
ds.Employee[0].ReportsTo = "Paul";

در اين حالت ما از نام جداول و فيلدها بصورت اسامی يک سری صفت تعريف شده و مشخص استفاده کرده ايم و نه بصورت يک عبارت حرفی که می تواند حاوی هر چيزی باشد. بعبارت ديگر در اين حالت ما اصولاً مجاز به استفاده از نام يا نامهای ديگری نيستيم و تنها از نامهای تعيين شده برای يک سری صفت يا متد بايد استفاده کنيم. خطاهای موجود در کد برنامه فوق در زمان کامپايل برنامه اعلام می شود و اين مزيت بسيار قابل توجهی نسبت به DataSet معمولی می باشد.

مقايسه کد برنامه های فوق نشان می دهد که استفاده از Typed DataSet چقدر آسان و راحت بوده و به چه ميزان قابليت خواندن برنامه ما را بالا برده و سبب می شود تا به آسانی برنامه خود را مديريت و نگهداری کنيم.

همه مقالات ADO.NET و پايگاه داده را ببينيد.
جستجو: بگرد!
جستجوی پيشرفته
نام کاربری |
کلمه عبور |


IranASP.NET - نمايش اطلاعات در DataGrid

نمايش اطلاعات در DataGrid

مهناز غلامی | اين مقاله ۶۲۱۷ بار تاکنون ديده شده است.
۱۳۸۲/۵/۷ | برای وبلاگ برای وبلاگ
نمايش تمام رکوردهای جدول SQL در DataGrid (پر کردن DatasGrid)

برای برقراری ارتباط با بانک اطلاعاتی ابتدا يک Connection String همانند مثال زير تعريف کنيد:

Dim connect As New System.Data.OleDb.OleDbConnection("Provider=SQLOLEDB.1;Password=yourpassword;User ID=youruserid;Initial Catalog=yourdatabase;Data Source=yourserver;")

سپس بايد Connection را باز کنيم:

connect.Open()

برای واکشی همه فيلدها از جدول مورد نظر متغيری به نام Sqlstr از نوع string تعريف می کنيم:

Dim SQLstr As String = "SELECT * FROM Tablename "

برای برقرار نمودن ارتباط ميان بانک اطلاعاتی وکنترل مورد نظرمان (در اينجا DataGrid) در اينجا می توان از DataAdaptor و DataSet استفاده کرد. DataAdaptor بر اساس دستورمتغير sqlstr و نام Connectionمان تعريف می شود:

Dim myDataAdapter As New System.Data.OleDb.OleDbDataAdapter(strSQL, connect)
Dim myDataSet As New DataSet()
myDataAdapter.Fill (myDataSet, "Tablename")

حال زمان تعريف و ارتباط DataGrid با جدولمان است:

DataGrid1.DataSource = myDataSet.Tables("Tablename")
DataGrid1.DataBind()

در انتها بايد Connection را ببنديم:

connect.Close()

همه مقالات ADO.NET و پايگاه داده را ببينيد.
جستجو: بگرد!
جستجوی پيشرفته
نام کاربری |
کلمه عبور |


IranASP.NET - استخراج داده از XML در ASP.NET

استخراج داده از XML در ASP.NET

بهنام يوسفی شمالی | اين مقاله ۳۹۹۲ بار تاکنون ديده شده است.
۱۳۸۲/۵/۱۶ | برای وبلاگ برای وبلاگ
در اين مقاله با يکی از روشهای ساده استخراج داده از XML به عنوان منبع برای داده های کوچک آشنا می شويم.

يکی از انتخاب های ما برای استخراج داده ها از فايلهای xml استفاده از dataset و يا XMLDocument است که با توجه به منابع زيادی که هر دو اينها استفاده می کنند در بعضی شرايط قابل استفاده نيستند. در اين موارد پيشنهاد می شود که از XMLTextReader برای اين منظور استفاده شود. XMLTextReader نوعی دسترسی سريع و روبه جلو (ForwardOnly) را برای ما مهيا ميکند که در ضمن به خاطر ويژگی non-cached بار زيادی به حافظه اعمال نمی کند.

چند متدی که معمولا بيشتر استفاده می شوند :

()Read که تقريبا شبيه متد هم نام خود در DataReader عمل می کند.

()ReadElementString متن درون المنت را برمی گرداند.

و همچنين ويژگی Item که Attributeها و مقادير آنها را نگهداری ميکند. شما با استفاده از HasAttributes می توانيد مطمئن شويد که يک المنت دارای Attribute هست يا خير.

مثال:

به اين فايل XML توجه کنيد :

<?xml version="1.0" encoding="utf-8" ?>
<Root>
<data>
<id>1</id>
<into date="2003-02-18" where="ايران" />
<comment show="true" title="hi!" />
</data>
<Root>

من برای خواندن Attributeها از المنت comment و متن المنت id از اين فايل XMLای که در بالا آمده اينچنين عمل می کنم:

Dim xrdr As New XmlTextReader(path)
Dim s, t, id As String

While xrdr.Read()

If xrdr.HasAttributes And xrdr.name="comment" Then

s = xrdr.item("show")

t = xrdr.item("title")

ElseIf xrdr.name="id" Then

id = xrdr.ReadElementString ()

End If

End While

xrdr.Close()

استفاده از XML به عنوان منابع داده های کوچک می تواند ما را در بسياری از عمليات برنامه های کاربردی وب کمک کند. به خصوص برنامه هايی که به مصرف منابع حساس هستند.

همه مقالات کليات ASP.NET را ببينيد.
جستجو: بگرد!
جستجوی پيشرفته
نام کاربری |
کلمه عبور |


IranASP.NET - XML و خواندن اطلاعات از آن

XML و خواندن اطلاعات از آن

علی حاج شفيعيها | اين مقاله ۴۱۹۵ بار تاکنون ديده شده است.
۱۳۸۲/۵/۲۲ | برای وبلاگ برای وبلاگ
روش تبديل اطلاعات از بانک اطلاعاتی به XML و نمايش اطلاعات آن

در اين مقاله سعی دارم که نحوه نوشتن در XML و خواندن از آن را شرح دهم. برای مثال ما يك وبلاگ داريم که اطلاعات را از بانک اطلاعاتی Access می خواند. ولی من برای اينکه همين اطلاعات را در يک فايل XML هم داشته باشم اين کد را به Load صفحه اضافه کردم:

Dim DS As New DataSet()
Dim strConnect As New OleDbConnection(ConfigurationSettings.AppSettings("datasource"))
Dim objSQLAdapter As New OleDbDataAdapter("SELECT * from blog order by id DESC", strConnect)
objSQLAdapter.Fill(DS, "blog")
Dim doc As XmlDataDocument = New XmlDataDocument(DS)
Dim writer As XmlTextWriter = New XmlTextWriter("D:\www\weblog\weblog.xml", Nothnig)
writer.Formatting = Formatting.Indented
doc.Save(writer)

در اين کد با استفاده از شئ DataSet، اطلاعات را از جدول مورد نظر بانک اطلاعاتی خود می خوانيم و آن را در يک فايل XML به نام weblog.xml ذخيره می کنيم. اگر اين کد را اجرا کنيم يک فايل XML ايجاد می شود و هر وقت صفحه اول اجرا شود فايل XML رونويسی می شود.

اما حالا يک فايل XML داريم و می خواهيم از آن استفاده کنيم. مخصوصا استفاده از XML برای سايت های خبری يا وبلاگ ها بسيار مناسب است. مثلا فرض کنيد که می خواهيم خبرهای موجود در يک سايت ديگر که به شکل XML ارائه می شوند (مانند RSS) را در سايت خودمان نمايش دهيم. برای اين کار ابتدا يک فايل ASPX ايجاد کنيد و اين کد را در قسمت Design يا همان HTML آن بنويسيد.

<asp:DataList id="theDataList" runat="server" Width="100%" dir=rtl CssClass=text>
<ItemTemplate>
تاريخ :<%# DataBinder.Eval(Container.DataItem, "news_date") %><br>
عنوان : <%# DataBinder.Eval(Container.DataItem, news_title") %><br><br>
<%# DataBinder.Eval(Container.DataItem, "news_body") %><br>
<hr>
</ItemTemplate>
</asp:DataList>
<br>

ما در اينجا يک کنترل DataList ايجاد کرديم و مقادير مورد نظر را در آن نوشتيم. حالا کدی که در Load اين صفحه بايد بنويسيم به اين شکل خواهد بود:

Dim ds As New DataSet()
ds.ReadXml("d:\www\weblog\weblog.xml", XmlReadMode.Auto)
theDataList.DataSource = ds
theDataList.DataBind()

اگر اين صفحه را اجرا کنيد تمام فيلدهای XML در اين فايل ASP.NET نمايش داده خواهد شد. در مثال بالا از يک فايل XML موجود بر روی ديسک استفاده شده است حال آنکه می توانيم بجای اين آدرس محلی از يک آدرس موجود در وب که همان آدرس سايت مورد نظر است استفاده کنيم. مثلا اگر بخواهيد اخبار سايت مورد نظر را در سايت خود نمايش دهيد کافی است اينگونه عمل کنيد:

Dim ds As New DataSet()
ds.ReadXml("http://www.website.com/weblog.xml",XmlReadMode.Auto)
theDataList.DataSource = ds
theDataList.DataBind

همه مقالات کليات ASP.NET را ببينيد.
جستجو: بگرد!
جستجوی پيشرفته
نام کاربری |
کلمه عبور |


IranASP.NET - آشنايی با کنترل DataList

آشنايی با کنترل DataList

ميلاد کرباسی زاده | اين مقاله ۳۷۰۸ بار تاکنون ديده شده است.
۱۳۸۲/۶/۲ | برای وبلاگ برای وبلاگ
نمايش داده های يک جدول از بانک اطلاعاتی در يک DataList

در اين مقاله کنترل DataList را بررسی خواهيم کرد. پيشنهاد ميکنم برای خواندن و اجرای کد برنامه حتما از ويژوال استوديو استفاده کنيد.

کنترل DataList کنترلی برای نمايش داده ها با هر فرمتی ميباشد. ميتوانيم خاصيت DataSource اين کنترل را يک Table از DataSet انتخاب کنيم و بعد با متد DataBind داده ها را از روی DataBase نمايش دهيم.

برای فهم بهتر اين موضوع نمونه برنامه زير را اجرا کنيد:

[Code Behind - VB.NET]

Dim Conn As New OleDbConnection
Dim Comm As New OleDbCommand
Dim ds As New DataSet
Dim adp As New OleDbDataAdapter

Private Sub Page_Load(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles MyBase.Load
Conn.ConnectionString = "Your ConnectionString"
Comm.CommandText = "Select Top 10 * from TableName"
Comm.Connection = Conn
adp.SelectCommand = Comm
adp.Fill(ds, "Blog")
Conn.Close()
DataList1.DataSource = ds.Tables("Blog").DefaultView
DataList1.DataBind()
End Sub

[HTML Code]

<asp:DataList Width="100%" id="DataList1" runat="server">
<ItemTemplate>
<font color="Orange"><%# databinder.Eval(container.dataitem,"RowName") %></font>
</ItemTemplate>
</asp:DataList>

در کد HTML به جای RowName اسم فيلدی را که مايليد قرار دهيد. در تگ <ItemTemplate> ميتوانيد فرمت نمايش داده ها را مشخص کنيد. تگ های <HeaderTemplate> و <FooterTemplate> نيز برای فرمت عنوان و پايان ليست مورد استفاده قرار ميگيرند. آرگومان دوم متد Eval نيز نام ستون مورد نظر را ميگيرد.

Happy DataListing!

همه مقالات فرم های وب را ببينيد.
جستجو: بگرد!
جستجوی پيشرفته
نام کاربری |
کلمه عبور |


IranASP.NET - گرافيک در ASP.NET

گرافيک در ASP.NET

مجتبی کيانی | اين مقاله ۴۵۵۹ بار تاکنون ديده شده است.
۱۳۸۲/۶/۲۲ | برای وبلاگ برای وبلاگ
آموزش چگونگی رسم تصاوير بصورت پويا در ASP.NET

برای کار در قسمت گرافيکی ابتدا بايد فضانام های System.Drawing و System.Drawing.2D را اضافه کنيد سپس يک شئ Bitmap و يک شئ Graphics برای کار کردن تعريف کنيد:

Dim bmp As New Bitmap (400, 400)
Dim g As Graphics = Graphics.FromImage (bmp)
g.Clear(Color. White)

حال می توانيم با استفاده از متدهای Graphics به رسم اشکال مختلف بپردازيم. برای رسم هر شکل تو خالی از يک متد Draw و برای رسم هر شکل تو پر از متد Fill استفاده می کنيم . هميشه هنگام استفاده از Draw بايد يک Pen وهنگام استفاده از Fill از يک Brush استفاده کنيد:

Dim bru As New Solid Brush (Color.Red)
Dim ps As New Pen (Color. Blue)
g.FillRectangle (b, New Rectangle (-10, -10, 320, 220))
Dim rec As New Rectangle (-100, -75, 200, 100)
g.DrawPie (ps, rec, 0, 180)

خوب حالا نوبت نمايش عکسی است که توليد کرده ايم برای اين کار کافی است Response.contenttype ر ا تنظيم نماييم. به ياد داشته باشيد که در انتها لازم است تا با فراخوانی متد Dispose، شئ های Bitmap و Graphics را از بين ببريم:

response.contenttype="image/jpeg"
'Send the image to the viewer
(bmp.save (response.outputstream, imageformat.jpeg
bmp.dispose ()
g.dispose ()

خوب حالا احتمالا يک مشکل کوچکی وجود دارد آن هم اين که تمام يا قسمتی از تصوير ساخته شده قابل ديدن نيست. اين مشکل به دليل قرارگرفتن مبدا مختصات در کناره بالا و سمت چپ تصوير به وجود می آيد در حقيقت محور Yها وارونه قرار گرفته است:

برای رفع اين مشکل از کلاس Matrix استفاده می کنيم اين کلاس با دو بردار يکه در فضای سه بعدی تعريف می شود که هر يک از اين دو بردار در حالت عادی به صورت(1,0,0) هستند. جهت چرخاندن محور Yها کافيست 1 را به 1- تبديل کنيم برای تغيير دادن محل مبدا نيز از متد Translate ماتريکس استفاده ميکنيم. سپس بايد اين تغيير را در Graphics اعمال کنيم:

Dim mt As Matrix = New Matrix (1, 0, 0, -1, 0, 0)
mt.Translate (150, 100)
g.Transform = m

دقت داشته باشيد که اين قسمت بايد بلافاصله بعد از تعريف Graphics اضافه شود.

برای رسم اشکال سه بعدی بايد با رسم هر يک از وجوه آن اشکال به طور جداگانه آن اشکال را بسازيم. مثلا برای رسم يک مکعب بايد کد زير را وارد کنيم:

Dim pf(5) As PointF
'--------------- متوازی الاضلاع بالايی
pf(0) = New PointF(120, 120)
pf(1) = New PointF(180, 120)
pf(2) = New PointF(150, 90)
Pf(3) = New PointF(120, 90)
pf(4) = New PointF(120, 120)
g.FillPolygon (bru, pf)
'--------------- متوازی الاضلاع كناری
bru.Color = Color.BlueViolet
pf(0) = New PointF(150, 90)
pf(1) = New PointF(180, 120)
pf(2) = New PointF(180, 180)
pf(3) = New PointF(150, 210)
pf(4) = New PointF(150, 90)
g.FillPolygon(bru, pf)
'----------------- مستطيل جلويی
bru.Color = Color.SteelBlue
pf(0) = New PointF(90, 90)
pf(1) = New PointF(150, 90)
pf(2) = New PointF(150, 210)
pf(3) = New PointF(90, 210)
pf(4) = New PointF(90, 90)
g.FillPolygon(bru, pf)

همه مقالات کليات ASP.NET را ببينيد.
جستجو: بگرد!
جستجوی پيشرفته
نام کاربری |
کلمه عبور |


IranASP.NET - چگونه صفحات فارسی خود را می سازيم؟

چگونه صفحات فارسی خود را می سازيم؟

مديريت سايت | اين مقاله ۶۵۷۱ بار تاکنون ديده شده است.
۱۳۸۲/۶/۲۹ | برای وبلاگ برای وبلاگ
مقاله ای در پاسخ به نامه های فراوان رسيده در مورد اينکه سايت IranASP.NET چگونه صفحات فارسی خود را می سازد.

در پاسخ به نامه های بسيار زيادی که همچنان در مورد نحوه و چگونگی ساخت صفحات فارسی و اينکه سايت IranASP.NET چگونه صفحات فارسی خود را توليد می کند دريافت می کنم، تصميم گرفتم که صرفاً نحوه کار خود را در اين مقاله جهت استفاده ديگران بياورم. اين روش به هيچ عنوان يک راهکار اصولی و استاندارد نبوده و صرفاً روشی است که من در تهيه صفحات فارسی اين سايت از آن استفاده می کنم و لزوماً بهترين روش نيست. بديهی است که انتخاب اين روش يا روشهای ديگر بعهده خواننده می باشد.

روش NotePad به اضافه FrontPage!
برای فارسی نويسی به شکلی که راحت تايپ شود و درست هم ديده شود، بدليل تعدد سيستمهای عامل بخصوص ويندوز و مشکلات خط فارسی در دنيای کامپيوتر تا به امروز متاسفانه راه مشخص و استانداردی وجود ندارد يا حداقل من نديده ام و هرکس روش خود را دارد که بعضاً با سعی و خطا به آن رسيده است. بهرحال چون در مورد خاص سايت IranASP.NET پرسيده شده است، من روش خود را می گويم.

من از خانواده ويندوز 2000 استفاده می کنم. لازم است که زبان Arabic را در اين ويندوز نصب کنيد (Control Panel-> Regional Settings) و سپس صفحه کليد Farsi را نيز از ليست مربوطه انتخاب و به ويندوز خود اضافه نمائيد.

جهت راحتی کار و سادگی NotePad من از NotePad برای تايپ متون فارسی خود استفاده می کنم. سپس متن تايپ شده را انتخاب و کپی کرده (Ctrl-C) و به FrontPage منتقل (paste) می کنم. نسخه FrontPage شما بايد 2000 به بالا باشد. سپس در همان FrontPage در پائين صفحه حالت HTML صفحه را با کليک برروی HTML می بينم. دقت داشته باشيد که تگ زير را در بالای کد HTML در قسمت Head داشته باشيد:

<meta http-equiv="Content-Type" content="text/html; charset=windows-1252">

به عبارت windows-1252 دقت کنيد که چيز ديگری نباشد و اگر بود آن را به اين مقدار تغيير دهيد و يکبار ديگر به حالت Normal و سپس به حالت HTML صفحه برگرديد. حال مثلا برای جمله "اين يک Test است" کدهای زير را خواهيد ديد:

&#1575;&#1610;&#1606; &#1610;&#1705; Test &#1575;&#1587;&#1578;

حال می توانيد اين کد را کپی کرده و در صفحات خود قرار دهيد. محاسن و معايب اين کار به شرح زير است:

محاسن:
• صفحات فارسی شما بر روی هر کامپيوتر و سيستم عاملی بعنوان server قابل استفاده است (portable).
• صفحات شما بر روی هر کامپيوتری بعنوان client قابل مشاهده است.
• نيازی نيست که تنظيمات اضافه ای در صفحات خود داشته باشيد بجز همان تگ بالا يعنی:

<meta http-equiv="Content-Type" content="text/html; charset=windows-1252">

يا

<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">

معايب:
• چند مرحله ای بودن کار
• نياز به نرم افزار خاصی مانند FrontPage
• عدم تشخيص کلمات و جملات فارسی در کد HTML و در نتيجه مشکل بودن انجام تغييرات در متن
• سنگين شدن صفحات به دليل استفاده از شش کاراکتر برای هر حرف فارسی مانند &#1575; برای حرف الف که در يونيکد نهايتا بيش از سه بايت نيست.

اگر قرار است از اين روش در ASP.NET استفاده کنيد، بصورت پيش فرض تقريبا هيچ مشکلی نداريد اما برای استفاده در ASP کلاسيک لازم است که خط زير را در بالای صفحه تان بعنوان اولين خط داشته باشيد:

<%@ Language="VBScript" CodePage="65001" %>

دقت داشته باشيد که اينگونه نيست که همه سايتهای فارسی زبان از اين روش مشکل استفاده می کنند، بلکه آنها روش خود را دارند.

همچنين ساخت صفحات فارسی در FrontPage XP/2002 بسيار آسانتر شده است و احتمالا نيازی به استفاده از اين روش نداريد اما اين روش همچنان مزايای خود را دارد و بسته به سليقه و نياز شما، می تواند مورد استفاده قرار گيرد.

همه مقالات فارسی در وب را ببينيد.
جستجو: بگرد!
جستجوی پيشرفته
نام کاربری |
کلمه عبور |


IranASP.NET - انواع روشهای انتقال مقادير بين فرمهای وب ASP.NET

انواع روشهای انتقال مقادير بين فرمهای وب ASP.NET

احسان وليزاده | اين مقاله ۴۸۲۲ بار تاکنون ديده شده است.
۱۳۸۲/۶/۲۹ | برای وبلاگ برای وبلاگ
در اين مقاله انواع روشهای مختلف موجود برای ارسال مقادير بين فرمهای وب ASP.NET بررسی می‌شوند.

مقدمه

فرمهای وب ASP.NET، مدل برنامه‌نويسی رويدادگرای شگرفی را برای توسعه‌گران فراهم می‌كنند. اين موضوع طراحی سرتاسر برنامه كاربردی شما را ساده می‌كند ولی مسائل و مشكلات خاص خود را نشان می‌دهد. برای مثال، در ASP كلاسيك شما به آسانی می‌توانيد مقادير را با استفاده از POST از يك صفحه ASP به صفحه‌ای ديگر ارسال نماييد. اما اگر می‌خواهيد در مدل فرمهای وب (يا همان مدل برنامه‌نويسی ASP.NET) برنامه‌نويسی كنيد، همان چيز در ASP.NET ممكن نمی‌باشد. اما راههايی برای غلبه بر اين وضعيت وجود دارند كه می‌توانند مورد استفاده قرار بگيرند. در اين مقاله موضوعات زير را مورد بررسی قرار خواهيم داد:

• چگونگی ارسال مقادير با استفاده از Querystring
• چگونگی استفاده از متغيرهای Session برای ارسال مقادير
• چگونگی استفاده از متد Server.Transfer برای ارسال مقادير

استفاده از Querystring

Querystring يك مكانيسم قديمی برای ارسال مقادير در بين صفحات است. مزيت اصلی اين متد سادگی آن است. اما عيب آن اين است كه پس از ارسال، مقادير در نوار آدرس مرورگر قابل مشاهده می‌باشند و نمی‌توان آبجكت‌ها را از اين طريق ارسال كرد. اين متد مناسب‌ترين راه برای ارسال تعداد كمی از مقاديری است كه نيازی به محافظت از ديد ديگران ندارند. برای اعمال كردن اين متد مراحل زير را انجام دهيد:

• يك فرم وب با كنترل‌هايش را درست كنيد
• يك كنترل دكمه‌ای Button يا LinkButton برای ارسال فرم به سرور بر روی فرم قرار دهيد
• در رويداد كليك دكمه يك متغير از نوع String تعريف كنيد كه URL را برای فرم ديگر كه مقادير قرار است به آنجا ارسال شوند، نگه می‌دارد.
• مقادير كنترل‌ها را در قالب پارامترهای QueryString در متغير از نوع String قرار دهيد
• از متد Response.Redirect كه از متغير String تعريف شده استفاده می‌كند برای هدايت كاربر به صفحه ديگر استفاده نماييد

قطعه كد زير چگونگی انجام اين مراحل را نشان می‌دهد:

فرم وب منبع

private void Button1_Click
(object sender, System.EventArgs e)
{
string url;
url="anotherwebform.aspx?name=" +
TextBox1.Text + "&email=" +
TextBox2.Text;
Response.Redirect(url);
}

فرم وب مقصد

private void Page_Load
(object sender, System.EventArgs e)
{
Label1.Text=Request.QueryString["name"];
Label2.Text=Request.QueryString["email"];
}

استفاده از متغيرهای Session

در اين روش بايد مقادير كنترل‌ها را در متغيرهای Session ذخيره كنيم و در فرم وب ديگری به آنها دسترسی داشته باشيم. همانطور كه می‌دانيد ذخيره داده‌های زياد در Session ممكن است اختلالاتی را در سرور بوجود آورد، بنابراين بايد از اين متد بدرستی استفاده شود. البته هر وقت كه خواستيد می‌توانيد متغيرهای Session را از بين ببريد. مراحل اصلی برای استفاده از اين متد به ترتيب زير می‌باشد:

• يك فرم وب با كنترل‌هايش را درست كنيد
• يك كنترل دكمه‌ای Button يا LinkButton برای ارسال فرم به سرور بر روی فرم قرار دهيد
• در رويداد كليك دكمه، متغيرهای Session را تعريف كرده و مقادير كنترل‌ها را در آنها قرار دهيد
• كاربر را با استفاده از Server.Transfer به صفحه‌ای ديگر هدايت كنيد
• در فرم وب ديگر متغيرهای Session را دريافت كرده و پس از دريافت اگر لازم باشد آنها را پاك كنيد.

كد زير اين مراحل را در عمل نشان می‌دهد:

فرم وب منبع

private void Button1_Click
(object sender, System.EventArgs e)
{
//textbox1 and textbox2 are webform
//controls
Session["name"]=TextBox1.Text;
Session["email"]=TextBox2.Text;
Server.Transfer("anotherwebform.aspx");
}

فرم وب مقصد

private void Page_Load
(object sender, System.EventArgs e)
{
Label1.Text=Session["name"].ToString();
Label2.Text=Session["email"].ToString();
Session.Remove("name");
Session.Remove("email");
}

استفاده از Server.Transfer

اين روش متدی پيچيده ولی روش ماهرانه‌ای برای ارسال مقادير بين صفحات است. در اينجا مقاديری را كه می‌خواهيد در صفحات ديگر به آنها دسترسی داشته باشيد به عنوان خصوصيات كلاس صفحه بيان می‌كنيد. در كل اين متد واضحتر و شئ‎گراتر از متدهای قبلی است. مراحل زير را برای استفاده از اين متد بترتيب دنبال كنيد.

• يك فرم وب با كنترل‌هايش را درست كنيد
• رويدادهای خصوصيت Get كه مقادير كنترل‌ها را برخواهند گرداند را تعريف كنيد
• يك كنترل دكمه‌ای Button يا LinkButton برای ارسال فرم به سرور بر روی فرم قرار دهيد
• در رويداد كليك دكمه متد Server.Transfer كه اجرای برنامه را به فرم تعيين شده انتقال می‌دهد فراخوانی كنيد
• در فرم دوم شما می‌توانيد با استفاده از خصوصيت Context.Handler به يك نمونه از فرم اول دسترسی داشته باشيد. سپس می‌توانيد از خصوصيات Get كه برای دسترسی به مقادير كنترل‌ها ايجاد كرده‌ايم استفاده كنيد.

كد زير برای اجرای يك نمونه از مراحل بالا تدارك ديده شده است:

فرم وب منبع

خصوصيات زير را به فرم وب اضافه كنيد:

public string Name
{
get
{
return TextBox1.Text;
}
}

public string EMail
{
get
{
return TextBox2.Text;
}
}

حال Server.Transfer را فراخوانی كنيد.

private void Button1_Click
(object sender, System.EventArgs e)
{
Server.Transfer("anotherwebform.aspx");
}

فرم وب مقصد

private void Page_Load
(object sender, System.EventArgs e)
{
//create instance of source web form
WebForm1 wf1;
//get reference to current handler instance
wf1=(WebForm1)Context.Handler;
Label1.Text=wf1.Name;
Label2.Text=wf1.EMail;
}

يك مقاله مرتبط با اين مقاله را می‌توانيد در آدرس زير مشاهده فرماييد:

http://www.iranasp.net/Articles/ShowArticle.aspx?articleid=102

همه مقالات فرم های وب را ببينيد.
جستجو: بگرد!
جستجوی پيشرفته
نام کاربری |
کلمه عبور |


IranASP.NET - ذخيره كردن Connection String در فايل Web.Config

ذخيره كردن Connection String در فايل Web.Config

احسان وليزاده | اين مقاله ۵۵۹۱ بار تاکنون ديده شده است.
۱۳۸۲/۶/۲۹ | برای وبلاگ برای وبلاگ
در اين مقاله روش ذخيره كردن Connection String در فايل Web.Config مورد بررسی قرار می‌گيرد.

مقدمه
بسياری اوقات برنامه‌های كاربردی نياز دارند كه چيزهای خاصی مانند Connection String (رشته اتصال) يا پارامترهای عمومی برنامه، به طور خارجی برای برنامه ذخيره شوند. راه قديمی برای اين كار استفاده از فايلهای INI يا وارد كردن آنها در Registry بود. البته هر كدام از اين روشها مشكلات خاص خود را دارند. ASP.NET راه مناسبی را برای انجام آن فراهم كرده است. شما می‌توانيد اين قبيل مقادير را قسمت <appSettings> فايل Web.Config ذخيره كنيد. كد زير بيانگر اين مطلب می‌باشد.

ذخيره كردن مقادير در Web.Config
كد زير را به فايل Web.Config خود اضافه كنيد:

<configuration>
<appSettings>
<add key="connectionstring"
value="Integrated Security=SSPI;
Initial Catalog=Northwind;
Data Source=MyServer\NetSDK" />
</appSettings>

فضانامهای مورد نياز
فضانامهای زير كلاسهای مورد نياز برای اين كار را فراهم می‌كنند:

System.Collections.Specialized
System.Configuration

كد VB.NET برای بازيابی مقادير
كد زير چگونگی بازيابی مقادير را با استفاده از VB.NET نشان می‌دهد:

Dim myvar As String
Dim nv As NameValueCollection
nv = ConfigurationSettings.AppSettings()
myvar = nv("connectionstring")

البته شما می‌توانيد اين كار را با سرعت بيشتری انجام دهيد:

Dim myvar As String
myvar=ConfigurationSettings.AppSettings("connectionstring")

كد #C برای بازيابی مقادير
كد زير چگونگی بازيابی مقادير را با استفاده از #C نشان می‌دهد:

string myvar;
NameValueCollection nv;
nv=ConfigurationSettings.AppSettings;
myvar=nv["connectionstring"];

از طريق كد زير، می‌توانيد اين كار را با سرعت بيشتری انجام دهيد:

string myvar;
myvar=ConfigurationSettings.AppSettings["connectionstring"];

اميدوارم كه مقاله برايتان مفيد باشد.

همه مقالات ADO.NET و پايگاه داده را ببينيد.
جستجو: بگرد!
جستجوی پيشرفته
نام کاربری |
کلمه عبور |


IranASP.NET - تشخيص هويت و تعيين اعتبار در ASP.NET

تشخيص هويت و تعيين اعتبار در ASP.NET

محمد نظارت | اين مقاله ۴۶۳۲ بار تاکنون ديده شده است.
۱۳۸۲/۷/۶ | برای وبلاگ برای وبلاگ
از موقعی که يک درخواست به وب سرور برای يک فايل که توسط ASP.NET سرويس داده می شود دريافت می گردد و تا موقعی که پاسخ درخواست به کاربر فرستاده می شود يک سری مراحل تشخيص هويت و تعيين اعتبار توسط IIS و ASP.NET صورت می گيرد.

ASP.NET بطور همزمان به همراه IIS و NET Framework. و يک سرويس امنيتی زيرلايه ای که توسط سيستم عامل اعمال می شود، برای ارائه يک سری از انواع تشخيص هويت (Authentication) و تعيين اعتبار (Authorization) کار می کند.

توصيف مکانيسم تشخيص هويت و تعيين اعتبار که توسط IIS و ASP.NET موقع رسيدن يک درخواست صورت می گيرد عبارت است از:

۱- يک تقاضای HTTP از طريق شبکه می رسد، SSL می تواند در اين بين برای حفظ امنيت انتقال اطلاعات از کاربران به سرور بکار رود.

۲- IIS بسته به نوع تنظيمات يک از روشهای تشخيص هويت Integrated (NTLM يا Kerberos)، Basic ،Digest يا Certificate استفاده می کند. چنانچه سايت شما نيازی به تشخيص هويت ندارد، می توانيد IIS را بصورت anonymous که در اين حالت (همه به صورت پيش فرض هويت شان تاييد می باشد) تنظيم کنيد. پس از آن IIS يک بسته اطلاعاتی حاوی هويت کاربر که توسط يکی از روش های بالا تاييد هويت شده است يا چنانکه بصورت anonymous تنظيم شده باشد يک بسته اطلاعاتی حاوی تشخيص هويت anonymous (که به صورت پيش فرض "User-Machine"می باشد) می سازد.

۳- IIS کاربر را برای دسترسی به منابع مورد درخواست تعيين اعتبار می کند. که در اين مرحله ممکن است ازحقوق امنيتی NTFS که در ACL وصل شده به منبع مورد درخواست برای تعيين اعتبار استفاده شود. و همچنين IIS می تواند برای پذيرفتن درخواست ها از کامپيوترهايی با IP های خاص تنظيم شود.

۴- IIS پس از اين اطلاعاتی که تاييد شده (که ممکن است anonymous باشد) را به ASP.NET می فرستد.

۵- ASP.NET کاربر را تشخيص هويت می نمايد. دراين مرحله اگر ASP.NET برای تشخيص هويت Windows تنظيم شده باشد هيچ گونه تشخيص هويت ديگر صورت نمی گيرد و اگر ASP.NET برای روش تشخيص هويت Forms تنظيم شده باشد مدارک ارائه شده توسط کاربر که از طريق فرم های HTML ارائه می شود با داده های ذخيره شده که بطور معمول در پايگاه داده SQL Server يا دايرکتوری سرويس Active Directory می باشد مقايسه می شود. و اگر ASP.NET برای روش تشخيص هويت Passport تنظيم شده باشد کاربر به سايت Passport مربوطه فرستاده می شود و عمل تشخيص هويت در آنجا صورت می گيرد.

۶- ASP.NET اعتبار کاربر را برای دستيابی به منابع يا پردازش های مورد درخواست بررسی می کند. UrlAuthorization Module (که از ماژول های HTTP ارائه شده توسط سيستم می باشد) از رُل های تعيين اعتبار که در فايل web.config (بويژه تگ<authorization>) تنظيم شده است. برای تاييد اعتبار کاربر نسبت به دسترسی به فايلها يا پوشه های مورد درخواست استفاده می کند. FileAuthorization Module (يکی ديگر از ماژول های HTTP) کاربر را برای دسترسی به فايل مورد نظر چک می کند که برای اين کار از ACL متصل به منبع مورد درخواست استفاده می شود. و همچنين رُل های NET. می تواند برای تعيين اعتبار کاربراستفاده شود که می توان آن را در فايل web.config يا بصورت برنامه ای تنظيم کرد.

۷- کد موجود در برنامه شما توسط يک هويت ويژه به منابع محلی يا دور دسترسی پيدا می کند که به صورت پيش فرض ASP.NET هيچگونه تقليد هويتی نمی کند و در نتيجه از حساب تنظيم شده پيش فرض ASP.NET برای تاييد استفاده می شود. و انتخاب ديگر استفاده از تائيديه کاربر اصلی است چنانچه تقليد هويت فعال شده باشد يا يک سرويس تائيديه تنظيم شده ديگر.

منبع: Building Secure ASP.NET Applications: Authentication, Authorization, and Secure Communication

همه مقالات کليات ASP.NET را ببينيد.
جستجو: بگرد!
جستجوی پيشرفته
نام کاربری |
کلمه عبور |


IranASP.NET - مقایسه نحوی ۴ زبان حاضر در ویژوال استودیو 2003

مقایسه نحوی ۴ زبان حاضر در ویژوال استودیو 2003

حسین پناهی | اين مقاله ۴۶۱۷ بار تاکنون ديده شده است.
۱۳۸۲/۷/۸ | برای وبلاگ برای وبلاگ
در این مقاله به بررسی و مقایسه اجمالی ۴ زبان J#.NET ،C++.NET ،VB.NET و C#.NET پرداخته میشود که این مقایسات به کمک مثال بیان میشود. این مقاله برای افرادی که قصد آموختن یکی از این زبانها را دارند بسیار مفید و کارآمد میباشد.

تعریف متغیرها

[VB.NET]
Dim x As Integer
Public x As Integer = 10

[J#.NET]
int x;
int x = 10;

[C++.NET]
int x;
int x = 10;

[C#.NET]
int x;
int x = 10;

نوشتن توضیحات در برنامه

[VB.NET]
' comment
x = 1 ' comment
Rem comment

[J#.NET]
// comment
/* multiline
comment */
/**
Class Documentation
*/

[C++.NET]
// comment
/* multiline
comment */

[C#.NET]
// comment
/* multiline
comment */

انتساب

[VB.NET]
nVal = 7

[J#.NET]
nVal = 7;

[C++.NET]
nVal = 7;

[C#.NET]
nVal = 7;

دستورات شرطی

[VB.NET]
If nCnt <= nMax Then
nTotal += nCnt ' Same as nTotal = nTotal + nCnt.
nCnt += 1 ' Same as nCnt = nCnt + 1.
Else
nTotal += nCnt
nCnt -= 1
End If

[J#.NET]
if (nCnt <= nMax){
nTotal += nCnt;
nCnt++;
}

[C++.NET]
if(nCnt < nMax) {
nTotal += nCnt;
nCnt++;
}
else {
nTotal += nCnt;
nCnt--;
};

[C#.NET]
if (nCnt <= nMax)
{
nTotal += nCnt;
nCnt++;
}
else
{
nTotal +=nCnt;
nCnt--;
}

دستورات انتخابی

[VB.NET]
Select Case n
Case 0
MsgBox ("Zero")
'VB.NET exits the Select at the end of a Case
Case 1
MsgBox ("One")
Case 2
MsgBox ("Two")
Case Else
MsgBox ("Default")
End Select

[J#.NET]
switch(n) {
case 0:
System.out.println("Zero\n");
break;
case 1:
System.out.println("One\n");
break;
default:
System.out.println("?\n");
}

[C++.NET]
switch(n) {
case 0:
printf("Zero\n");
break;
case 1:
printf("One\n");
break;
case 2:
printf("Two\n");
break;
default:
printf("?\n");}

[C#.NET]
switch(n)
{
case 0:
Console.WriteLine("Zero");
break;
case 1:
Console.WriteLine("One");
break;
case 2:
Console.WriteLine("Two");
break;
default:
Console.WriteLine("?");
}

حلقه For

[VB.NET]
For n = 1 To 10
MsgBox("The number is " & n)
Next

For Each prop In obj
prop = 42
Next prop

[J#.NET]
for(n=1; n<11;n++)
System.out.println("The number is " + n);

[C++.NET]
for(int n=1; n<11; n++)
printf("%d\n",n);

[C#.NET]
for (int i = 1; i <= 10; i++)
Console.WriteLine("The number is {0}", i);
foreach(prop current in obj)
{
current=42;
}

حلقه While

[VB.NET]
While n < 100 ' Test at start of loop.
n += 1 ' Same as n = n + 1.
End While

[J#.NET]
while (n < 100)
n++;

[C++.NET]
while(int n < 100)
n++;

[C#.NET]
while (n < 100)
n++;

انتقال پارامترها با مقدار

[VB.NET]
Public Sub ABC(ByVal y As Long)
...
End Sub
ABC(x)
ABC((x))

آرگومان y با مقدارش منتقل ميشود. اگر زيربرنامه ی ABC مقدار y را تغيير دهد اين تغييرات تاثيری بر روی x نخواهد داشت.
شما ميتوانيد پارامترها را مجبور کنيد که با مقدار منتقل شوند بدون توجه به چگونگی تعريف آنها. اين کار را می توانيد با گذاشتن يک جفت پرانتز () ديگر انجام دهيد.

[J#.NET]

اشياء همواره با آدرس و انواع داده ی اوليه هميشه با مقدار منتقل ميشوند.

[C++.NET]
MyMethod(i,j);
[C#.NET]

توجه کنيد که هيچ راهی برای انتقال انواع مرجع (اشياء) منحصرا از طريق مقدار وجود ندارد.

يک متد تعريف شده:

void ABC(int x)
{
...
}

و فراخوانی اين متد :

ABC(i);

انتقال پارامترها با آدرس

[VB.NET]
Public Sub ABC(ByRef y As Long)
End Sub

ABC(x)

پارامتر y به صورت ByRef (با آدرس) شده است. اگر ABC مقدار y را تغيير دهد اين تغييرات روی x نيز صورت ميگيرد.

[J#.NET]
[C++.NET]

پروتوتایپ تابع ABC که شامل اشاره گری به يک عدد است.

int ABC(long *py);
ABC(&VAR);

پروتوتایپ تابع ABC که شامل ارجاعی به يک عدد است.

int ABC(long &y);
ABC(VAR);
[C#.NET]

همنچنين توجه داشته باشيد که متد #C ميتواند مانند ++C شامل اشاره گر باشد. برای مثال اين متد:

void ABC(ref int x)
{
...
}
ABC(ref i);

مديريت استثنائات ساخت يافته

[VB.NET]
Try
If x = 0 Then
Throw New Exception("x equals zero")
Else
Throw New Exception("x does not equal zero")
End If
Catch err As System.Exception
MsgBox("Error: " & Err.Description)
Finally
MsgBox("Executing finally block.")
End Try

[J#.NET]
try{
if (x == 0)
throw new Exception ("x equals zero");
else
throw new Exception ("x does not equal zero");
}
catch (Exception err){
if (err.getMessage() == "x equals zero")
System.out.println(err.getMessage());
//Handle Error Here
}

[C++.NET]
__try{
if (x == 0)
throw new Exception ("x equals zero");
else
throw new Exception ("x does not equal zero");
}
__catch(Exception e)
{
Console.WriteLine("Caught Exception");
}
__finally
{
Console.WriteLine("Executing finally block");
}

[C#.NET]
// try-catch-finally
try
{
if (x == 0)
throw new System.Exception ("x equals zero");
else
throw new System.Exception ("x does not equal zero");
}
catch (System.Exception err)
{
System.Console.WriteLine(err.Message);
}
finally
{
System.Console.WriteLine("executing finally block");
}

رهاسازی ارجاعات اشياء

[VB.NET]
o = Nothing

[J#.NET]
stringVar = null;

[C++.NET]

[C#.NET]
o = null;

همه مقالات کليات ASP.NET را ببينيد.
جستجو: بگرد!
جستجوی پيشرفته
نام کاربری |
کلمه عبور |


IranASP.NET - نمايش تصاوير در DataGrid

نمايش تصاوير در DataGrid

احسان وليزاده | اين مقاله ۵۳۸۱ بار تاکنون ديده شده است.
۱۳۸۲/۷/۲۴ | برای وبلاگ برای وبلاگ دريافت کد
آشنايی با کنترل DataGrid و قابليتهای آن با استفاده از مثالی جهت نمايش تصاوير در آن

مقدمه
كنترل DataGrid پيچيده ترين كنترلی است كه در NET Framework. وجود دارد. با استفاده از اين كنترل امكان فرمت دهی و نمايش، مرتب‌سازی و صفحه بندی ركوردهای جداول بانك اطلاعاتی فراهم می‌شود. در اينجا می‌خواهيم با استفاده از قابليتهای اين كنترل روشی را برای نشان دادن تصاوير در آن بررسی كنيم. هر كدام از اين تصاوير قرار است در ركورد مربوط به خود در كنترل DataGrid نمايش داده شوند. هر ركورد داده‌های ديگری را نيز شامل می‌شود كه همه آنها در جدول products واقع در پايگاه داده products.mdb قرار دارند. هر ركورد شامل ستونی به نام ImageName (از نوع داده Text) می‌باشد كه نام تصوير مربوط به ركورد را شامل می‌شود.

تعريف ستون برای كنترل DataGrid
وقتی كه يك منبع داده مانند يك DataSet را به كنترل DataGrid مقيد (Bind) می‌كنيم، خود كنترل همه كارها را انجام می‌دهد و همه ركوردها را به طور خودکار نمايش می‌دهد. ولی اگر بخواهيم ستونهای كنترل DataGrid را تحت كنترل خود درآورده و فقط ستونهای دلخواه را نمايش دهيم بايد خودمان برای كنترل DataGrid ستون تعريف كنيم. قبل از اينكه بتوانيم ستونی را برای DataGrid تعريف كنيم، لازم است كه خصوصيت AutoGenerateColumns آنرا برابر False قرار دهيم. پس از انجام اين كار می‌توانيم شروع به تعريف ستون برای كنترل DataGrid نماييم. كنترل DataGrid پنج نوع ستون را می‌شناسد كه عبارتند از:

• BoundColumn: نوع پيش فرض ستونها كه ركوردها را نمايش می‌دهد.
• HyperLinkColumn: كه ركوردها را به صورت يك Hyperlink نمايش می‌دهد.
• TemplateColumn: كه ركوردها را با استفاده از يك الگوی مشخص نمايش می‌دهد.
• ButtonColumn: كه كنترلهايی از نوع Button را نمايش می‌دهد.
• EditCommandButton: كه فرامين ويرايش همانند Edit، Update و Cancel را نمايش می‌هد.

در نمونه كدی كه همراه مقاله ميتوانيد آنرا دريافت كنيد، كنترل DataGrid را به صورت زير تعريف كرده ايم :

<asp:Datagrid id="dg" runat="server" AutoGenerateColumns="False" BorderColor="Black" Font-Size="10" Font-Name="Arial" BackColor="#C6C3FF" Headerstyle-Font-Size="12" Headerstyle-Font-Bold="True" Headerstyle-Font-Name="Arial" Headerstyle-Forecolor="#0F0F0F" Headerstyle-BackColor="#8482C6" cellspacing="0" cellpadding="0" GridLines="Both">
<columns>
<asp:BoundColumn HeaderStyle-HorizontalAlign="Center" DataField="ProdName" HeaderText="ProdName"></asp:BoundColumn>
<asp:TemplateColumn HeaderStyle-HorizontalAlign="Center">
<HeaderTemplate>
Images
</HeaderTemplate>
<ItemTemplate>
<div align="center">
<img src='/prodimages/<%# Container.DataItem("ImageName") %>' border="0" />
</div>
</ItemTemplate>
</asp:TemplateColumn>
<asp:BoundColumn DataField="Comments" HeaderText="Comments"></asp:BoundColumn>
</columns>
</asp:Datagrid>

در كدهای مربوط به كنترل DataGrid سه ستون برای آن تعريف شده است. ستون اول از نوع BoundColumn، ستون دوم از نوع TemplateColumn و ستون سوم هم دوباره از نوع BoundColumn تعريف شده‌اند. در ستونهايی كه از نوع BoundColumn می‌باشند، انتساب نام فيلد جدول بانك اطلاعاتی به خصوصيت DataField ستون، برای نمايش دادن داده‌های آن فيلد در ستون DataGrid كافی می‌باشد. كدهای زير مربوط به تعريف ستون اول اين DataGrid می‌باشد.

<asp:BoundColumn HeaderStyle-HorizontalAlign="Center" DataField="ProdName" HeaderText="ProdName"></asp:BoundColumn>

تعريف ستون TemplateColumn برای كنترل DataGrid
وقتی كه می‌خواهيم اختيارات بيشتری را در تعيين فرمت يك ستون داشته باشيم ستونی از نوع TemplateColumn را به تعريف می‌كنيم. ستونی كه از نوع TemplateColumn برای كنترل DataGrid تعريف می‌شود، می‌تواند الگوهای زير را داشته باشد:

• HeaderTemplate: تعيين كنندة فرمت متنی است كه در بالای ستون نمايش داده می‌شود.
• ItemTemplate: تعيين كنندة فرمت آيتم‌های اصلی ستون می‌باشد.
• EditItemTemplate: تعيين كنندة فرمت آيتمی است كه به قصد ويرايش انتخاب شده است.
• FooterTemplate: تعيين كنندة فرمت آيتمی است كه پايين ستون نمايش داده می‌شود.

در كد مربوط به تعريف كنترل DataGrid از دو الگوی HeaderTemplate و ItemTemplate استفاده شده است. در داخل HeaderTemplate كلمه Images نوشته شده است كه موقع اجرا در بالای ستون نمايش داده می‌شود. كار اصلی برای نمايش تصاوير در داخل الگوی ItemTemplate انجام شده است. در اينجا با كدهای HTMLی كه در زير دوباره آنها را مشاهده می‌كنيد توانسته‌ايم تصاوير مربوط به ركوردها را نمايش دهيم.

<div align="center">
<img src='/prodimages/<%# Container.DataItem("ImageName") %>' border="0" />
</div>

در اينجا با استفاده از تگ <img> تصاوير را از داخل پوشه prodimages نمايش داده‌ايم. نام تصاوير با استفاده از عبارت <%# Container.DataItem("ImageName") %> تعيين می‌شود كه اين عبارت مقدار ستون ImageName برای هر ركورد را باز می‌گرداند.
تمام كد مربوط به صفحه و همچنين پايگاه داده products.mdb را می‌توانيد در بالای همين صفحه دريافت نماييد.

همه مقالات فرم های وب را ببينيد.
جستجو: بگرد!
جستجوی پيشرفته
نام کاربری |
کلمه عبور |


IranASP.NET - نگاهی به ASP.NET Whidbey

نگاهی به ASP.NET Whidbey

مديريت سايت | اين مقاله ۴۶۱۷ بار تاکنون ديده شده است.
۱۳۸۲/۸/۷ | برای وبلاگ برای وبلاگ
نگاه مختصری به نسخه جديد ASP.NET به نام Whidbey و بررسی قابليتهای آن

مقدمه

امروزه Microsoft ASP.NET بصورت وسيعی در حال گسترش است. بسياری از سايتهای بزرگ ومعروف مانند Marrill Lynch ،DELL، بازار بورس لندن، NASDAQ، هواپيمايی JetBlue و USAToday و بسياری سايتهای ديگر از اين فناوری استفاده کرده اند.

هر روزه هزاران برنامه نويس اقدام به فراگيری ASP.NET کرده و تاکنون بيش از ۱۷۰ عنوان کتاب در مورد ASP.NET چاپ شده است. همچنين وبسايتهای زيادی در قالب سايتهای آموزشی، انجمنها و وبلاگها در اين زمينه وجود دارد.

ASP.NET "Whidbey"

نسل جديد ASP.NET که کد-نام آن Whidbey می باشد، گام بلندی است در زمينه افزايش کارايی و نيز قابليتهای جديدی که همگی حاصل تجربيات چند ساله جامعه بزرگ متخصصين ASP.NET است. اين نسخه‎ی جديد بصورت صد در صد با نسخه قبلی سازگار خواهد بود و تسهيلاتی جهت انتقال برنامه ها از نسخه قديم به نسخه جديد انديشيده شده است.

در طراحی Whidbey بطور عمده بر سه هدف تمرکز شده است:

  • بهره وری برنامه نويس
  • مديريت و نگهداری
  • سرعت و کارايی

بهره وری برنامه نويس

در طراحی Whidbey سعی شده است تا برنامه نويسان بتوانند برنامه های تحت وب حرفه ای را بسيار آسانتر و سريعتر از قبل بسازند. زمان بسيار زيادی صرف گفتگو با انواع برنامه نويسان و بررسی برنامه های موجود شده است تا بتوان نقاط اشتراک ميان آنها را مشخص نمود. سپس اين نقاط مشترک همگی بصورت بخشی از Whidbey درآمده و به ASP.NET اضافه شده است. برای مثال می توان به موارد جديد و آماده زير در Whidbey اشاره نمود.

  • سيستم شناسايی کاربر (username/ password)
  • سيستم شخصی سازی (personalization)
  • Master Pages جهت ايجاد يک قالب واحد برای کليه صفحات يک وبسايت
  • سيستم جديد پيمايش سايت (site navigation) جهت ساخت سريع ساختار لينکهای سايت
  • سيستم آمارگيری يا شمارنده برای تعداد بازديدکنندگان سايت و تعداد صفحات بازديد شده (site counter)
  • قالب های آماده جهت ساخت سريع نما و ظاهر سايت (theme)
  • بخش جديد ASP.NET Web Part جهت انواع مدلهای چيدمان پورتال (portal)

علاوه بر کليه موارد فوق، Whidbey شامل بيش از ۴۵ مورد کنترل (server control) جديد خواهد بود. اين کنترلها در زمينه های پايگاه داده، امنيت، توليد تصاوير، پيمايش وبسايت، منو، treeview و... خواهد بود.

برای ساخت صفحه ای در ASP.NET 1.0 که حاوی يک DataGrid که آن نيز شامل ليست بازشو (dropdownlist) در هر سطر خود می باشد، نياز بود که بيش از صد خط برنامه نوشت و به دفعات نيز به راهنمای مربوطه (help) مراجعه نمود. اما جالب است که بدانيد اين کار در Whidbey تنها در يک خط برنامه و ظرف چند ثانيه انجام خواهد شد. همه اين کارها در محيط برنامه نويسی جديدی برای Visual Studio .NET که اتفاقاً کد-نام آن نيز Whidbey است، انجام خواهد شد.

همه کنترلهای استاندارد Whidbey دارای يک واسط کاربری قوی خواهند بود بطوريکه بتوان همه انواع مرورگرها و دستگاههای موبايل را پشتيبانی کرد. همه اين کنترلها دارای پيشوند <:asp> خواهند بود و توسط آنها می توان بيش از ۳۰۰ نوع دستگاه موبايل با انواع زبانهای نشانه گذاری مانند XHTML Mobile ،WAP/WML و cHTML را سرويس‎دهی کرد.

در مجموع قابليتهای جديد Whidbey برای برنامه نويسان بسيار شگفت آور خواهد بود بطوريکه پروژه هايی که هم اکنون ممکن است روزها يا هفته ها زمان ببرند، تنها در عرض چند ساعت اجرا خواهند شد.

مديريت و نگهداری

در Whidbey هدف اين است که مديران سرورها (administrators) بتوانند ASP.NET را به آن اندازه ای که برنامه نويسان آن را دوست دارند، دوست داشته باشند. اين بمعنی ايجاد سهولت بيشتر در نصب، انتقال، نگهداری و مديريت سرورهای ASP.NET می باشد. در Whidbey ابزارها و APIهای جديدی ساخته شده است که بتوان به کمک آنها و بصورت برنامه ای، برنامه ها و اسکريپت‎هايی جهت ايجاد، خواندن و بروزرسانی فايلهای Web.config و Machine.config ساخت. همچنين يک ابزار مديريتی جديد بصورت گرافيکی کليه فايلهای XML مربوط به ساختاربندی (configuration) را مديريت می کند.

ابزاری همراه Whidbey ارائه خواهد شد تا بتوان به کمک آن و قبل از نصب برنامه‎ی وبسايت، نسخه ای بصورت پيش-کامپايل (pre-compile) تهيه نمود که محتوی همه اجزای برنامه حتی فايلهای aspx. نيز باشد و بدين ترتيب کد فايلهای شما بخصوص فايلهای متنی مانند aspx. و ascx. از چشم ديگران محفوظ مانده و امنيت کد برنامه شما افزايش می يابد.

سرعت و کارايی

امروزه ASP.NET سريعترين فناوری در زمينه برنامه های تحت وب در جهان است و هدف اين است که در Whidbey سرعت آن باز هم بيشتر شود.

Whidbey از تکنولوژی 64 بيتی بهره می برد و اين بمعنی سود بردن از تمام فضای آدرسی دهی و محاسباتی پردازنده های 64 بيتی است. برنامه نويسان می توانند برنامه های 32 بيتی قديمی خود را حتی بدون کوچکترين تغييری در کد برنامه بر روی سرور 64 بيتی Whidbey قرار دهند و برنامه های آنها بصورت خودکار به شکل JIT کامپايل شده و بصورت 64 بيتی اجرا خواهد شد.

همچنين Whidbey دارای قابليت خودکار باطل کردن cache مربوط به سرور پايگاه داده است. اين ويژگی برنامه نويسان را قادر خواهد ساخت تا بصورت حريصانه‎ای صفحات مبتنی بر پايگاه داده را cache کرده يا اصطلاحاً از انواع output cache بدون نگرانی استفاده کنند و مسووليت بروز رسانی آنها را در صورت تغيير داده های پايگاه داده بعهده ASP.NET بگذارند.

* * *

دقت داشته باشيد که هم اکنون پروژه Whidbey در مرحله آلفا قرار دارد و در حدود دو-سوم توانايیهای فوق به ASP.NET افزوده شده است. در بهار آينده نسخه کامل شده بتای آن ارائه خواهد و ممکن است قابليتهای بيشتری هم به آن افزوده شود. در آن هنگام می توان Whidbey را دريافت و نصب نمود و با آن عملاً برنامه نوشت.

جهت دريافت اطلاعات بيشتر و تکميلی به آدرس http://www.asp.net/whidbey مراجعه نمائيد.

جهت دريافت اطلاعات در مورد نسخه جديد Visual Studio .NET Whidbey به آدرس http://www.asp.net/whidbey/whitepapers/VSWhidbeyOverview.aspx مراجعه نمائيد.

ترجمه و خلاصه از ASP.NET "Whidbey" Overview

همه مقالات کليات ASP.NET را ببينيد.
جستجو: بگرد!
جستجوی پيشرفته
نام کاربری |
کلمه عبور |


IranASP.NET - گفتگو با علی خرد ور متخصص ASP.NET از کانادا

گفتگو با علی خرد ور متخصص ASP.NET از کانادا

مديريت سايت | اين مقاله ۷۶۹۱ بار تاکنون ديده شده است.
۱۳۸۲/۸/۱۹ | برای وبلاگ برای وبلاگ
گفتگو با علی خرد ور برنامه نويس ASP.NET از کانادا درباره خودش، NET.، زندگی و کار در کانادا و غيره.

مثل هميشه با يک ايميل شروع شد. مطالبی را به فارسی با استفاده از Word XP نوشته بود و بسيار مشتاق بود تا آنها را در اختيار ديگر فارسی زبانان بخصوص هموطنانش در ايران قرار دهد، اما نگران بود که آيا من می توانم فايلهای او را که بصورت یونيکد هستند را اينجا باز کرده و بخوانم يا نه. به او گفتم که علی جان! اتفاقاً ما در به در دنبال مطلب آنهم از نوع فارسی يونيکدی هستيم، بفرست بياد! جواب او اين بود: WOW! That sounds great!

و اين مقدمه آشنايی من با جناب آقای علی خرد ور متخصص ASP.NET از کانادا بود تا گفتگوی زير با وی را خدمت شما ارائه نمايم.

معرفی
• لطفاً خودتان را معرفی کرده و بفرمائيد در کجا سکونت داريد؟
اسم من علی خردور هست، 30 سال دارم و در شهر Toronto در کشور کانادا زندگی می کنم.

• اگر ممکن است E-mail خود را جهت اطلاع خوانندگان اعلام نمائيد.
خیلی خودمونی بگم که واقعاً از دیدن وضعیت NET. در ایران راضی هستم و بهتره بگم که در مقایسه با وضعیت کاربرد NET. در اینجا [کانادا] هیچ تفاوت خاصی نمی بینم و از این مسئله احساس غرور می کنم. مخصوصاً زمانی که سایتهای اینترنتی که با NET. ساخته می شن رو می بینم، واقعاً شگفت زده می شم.

akherad [at] hotmail.com

• مدرک تحصيلی شما چيست و از کجا گرفتيد؟
من مدرک کارشناسی خودم رو در سال 1375 از دانشگاه شهید بهشتی در رشته مهندسی کامپیوتر گرایش نرم افزار و مدرک کارشناسی ارشد خودم رو در همین رشته در سال 1380 از دانشگاه تربیت مدرس گرفتم.

• کجا کار می کنيد و زمينه های فعاليت شما کدامند؟
من در یک شرکت تولید کننده نرم افزار به نام Changepoint Corporation و در سمت Software Developer مشغول به کارم. این شرکت یک محصول نرم افزاری عمده برای مدیریت پروژه چه در زمینه IT و چه در زمینه های دیگر تولید می کنه که در حال حاضر قصد دارن که این محصول رو بر اساس تکنولوژی NET. بازنویسی کنن. من هم در همین زمینه با این شرکت همکاری می کنم.

• زندگی و کار در کانادا چگونه است؟
این سوال خیلی کلی هست. ببینید، زندگی در کانادا بر خلاف اونچه که شاید بعضی ها تصور می کنن نیست. مخصوصاً که بازار کار تو این مدت که من اینجا بودم اصلاً خوب نبوده. به هر حال اگه اینجا کسی یک کار مناسب داشته باشه، میتونه از امکانات اینجا استفاده کنه و زندگی نسبتاً خوبی داشته باشه، در غیر اینصورت زندگی خیلی هم سخت می گذره.
یکی از نکات منفی در اینجا، اینه که متاسفانه جامعه IT ایرانی در کانادا چندان فعال نیست و معمولاً بر خلاف مهاجرای دیگه (مثل هندی ها یا چینی ها) ایرانی ها چندان ارتباطی با هم ندارن و از هم پشتیبانی نمی کنن.

در دنيای صفر و يک
• اولين تجربه حرفه ای شما در زمينه کامپيوتر کدام است؟
اولین تجربه حرفه ای من نوشتن سیستم فروش یک فروشگاه بود که در سال 1371 با زبان Pascal نوشتم.

• چرا برنامه نويس شديد؟
من طرح کاد دوران دبیرستان رو در زمینه کامپیوتر گذروندم. در اون دوران من با Amiga 128 و به زبان Basic برنامه می نوشتم. از اونجا بود که به برنامه نویسی علاقمند شدم و این حرفه رو انتخاب کردم.
توصیه اصلی من روی کار گروهی و مدیریت صحیح پروژه است. برنامه نویسان ایرانی در استفاده از ابزار مشکل خاصی ندارن، ولی متاسفانه کار گروهی و مدیریت صحیح پروژه، نقطه ضعف اصلی صنعت تولید نرم افزار در ایران است.

• به غير از برنامه نويسی به چه چيزهايی علاقه منديد؟
تدریس یکی از محبوبترین کارهایی است که دوست دارم انجام بدم. من در ایران مدتی در شرکت داده پردازی ایران و مدتی هم در مجتمع فنی تهران تدریس کردم.

و اما بحث شيرين ASP.NET!
• کدام ويژگی يا امکانات ASP.NET را جالب تر ديد؟
من شخصاً از ایده Code Behind خیلی استقبال می کنم، چون میشه با استفاده از یک زبان برنامه نویسی کامل (نه زبان Script) منطق مورد نظر رو پیاده سازی کرد. همچنین امکان Smart Navigation و View State رو هم خیلی دوست دارم.

• #C يا VB.NET؟ چرا؟
این سوال اینجا تو محیط کار خیلی مطرحه. البته از اونجاییکه هر دو زبان برنامه نویسی #C و VB.NET از قابلیتهای تقریباً یکسانی برخوردار هستن، نمی شه به این سادگی از نظر قابلیت برنامه نویسی بین این دو تفاوتی گذاشت. من تا بحال ندیدم اینجا کسی بر اساس یک دلیل تکنیکی خاصی یکی رو بر دیگر ترجیح بده و عموماً انتخاب یکی از این دو زبان سلیقه ای بوده. برنامه نویسان هم بر اساس تجربه خودشون یکی رو انتخاب می کنن. من خودم هم با VB6 و هم با Java برنامه نوشتم. به همین دلیل با هر دو زبان #C و VB.NET برنامه NET. نوشتم و به هر دو زبان تسلط کافی دارم.

• NET. يا J2EE؟ چرا؟
من شخصاً NET. رو بر J2EE ترجیح میدم و علتش هم تنوع بیشتری است که در NET. می بینم. هم از تنوع Class Library که در NET. هست و هم در تعداد زبانهای برنامه نویسی که در اختیار برنامه نویس قرار می گیره. در ضمن کارایی برنامه های NET. رو هم بهتر می بینم.

• فکر می کنيد گرايش برنامه نويسان يا بازار کار به طرف کدام يک است، NET. يا J2EE؟
در حال حاضر برنامه نویسان به سمتی گرایش دارن که بتونن کار بهتر با درآمد بهتری داشته باشن. من فکر کنم که برنامه نویسان گرایش بیشتری به NET. دارن، ولی این چیزی است که بستگی کامل به پروژه داره. اینجا در آمریکای شمالی، هر دو شاخه، طرفدارای زیادی داره و شرکتهای معتبری، هر دو NET. و J2EE رو بکار می گیرن.

مايکروسافت و مدارکش...

• دارای چه مدارک يا گواهينامه های حرفه ای مانند مدارک مايکروسافت هستيد؟
من مدارک MCSD.NET ، MCAD.NET و MCP for SQL Server 2000 رو دارم.

• درباره مدارک مربوط به NET. بيشتر توضيح دهيد.
بطور کلی شرکت Microsoft دو نوع مدرک برای برنامه نویسان در نظر گرفته که با نام MCAD و MCSD شناخته می شن. MCAD برای برنامه نویسانی در نظر گرفته شده که بیشتر در مرحله کد کردن و آزمون و تحویل برنامه های کاربردی فعالیت می کنن. MCSD برای افرادی در نظر گرفته شده که در مرحله آنالیز، طراحی، کد کردن و آزمون و تحویل نرم افزار کار می کنن. همونطور که می بینین MCSD مدرکی است که MCAD رو هم پوشش می ده، ولی در عمل، وظیفه آنالیز و طراحی بر عهده داردندگان مدرک MCSD و وظیفه پیاده سازی و آزمون و تحویل نرم افزار بر عهده دارندگان مدرک MCAD است.
در حال حاضر، شرکت Microsoft، دو نوع از این مدارک رو ارائه میکنه: نوع اول مخصوص Visual Studio 6 و نوع دوم مخصوص NET. است. از اونجاییکه NET. محصول جدیدتری است، دارندگان این مدارک تعداد کمتری نسبت به نوع قبل دارن، اما امسال استقبال زیادی از NET. شده و برنامه نویسان تمایل بیشتری نسبت به مدارک NET. دارن.

• آيا اين مدارک توانسته است در موقعيت شغلی شما اثر گذار باشد؟ چگونه؟
مسلماً این مدارک تاثیر زیادی در موقعت کاری من داشته. ببینین، هر برنامه نویسی میدونه که در دنیای کامپیوتر، سرعت پیشرفت بسیار زیاده و برای اینکه بتونه خودشو بروز نگه داره، باید با این پیشرفت هماهنگ باشه. کارفرما هم دوست داره که از برنامه نویسانی استفاده کنه که با دانش روز آشنا باشن. داشتن این مدارک کمک میکنه که برنامه نویس به کارفرما نشون بده که با دانش تولید نرم افزار با استفاده از NET. آشنایی کامل داره و به این ترتیب موقعیت شغلی خودش رو تثبیت می کنه.

• سخت ترين سوالی يا سوالاتی که در امتحانات MCAD يا MCSD با آن برخورد نموديد کدام بوده است؟
سوالاتی که در امتحان 70-300 (مربوط به امتحان Solution Development) و 70-320 (مربوط به امتحان XML Web Services) بود، سوالات مشکلی بود. اما در کل سوالات مطرح شده، عموماً بصورت کاربردی بود. به عبارت دیگه، سوالات جنبه کاربردی داشت و برنامه نویس باید بر اساس تجربه خودش به سوالات جواب بده.

دات نت به سبک ايرانی

• نظرتان در مورد وضعيت NET. و متخصصين آن در داخل ايران چيست؟
خیلی خودمونی بگم که واقعاً از دیدن وضعیت NET. در ایران راضی هستم و بهتره بگم که در مقایسه با وضعیت کاربرد NET. در اینجا هیچ تفاوت خاصی نمی بینم و از این مسئله احساس غرور می کنم. مخصوصاً زمانی که سایتهای اینترنتی که با NET. ساخته می شن رو می بینم، واقعاً شگفت زده می شم.
من شخصاً NET. رو بر J2EE ترجیح میدم و علتش هم تنوع بیشتری است که در NET. می بینم. هم از تنوع Class Library که در NET. هست و هم در تعداد زبانهای برنامه نویسی که در اختیار برنامه نویس قرار می گیره. در ضمن کارایی برنامه های NET. رو هم بهتر می بینم.

اما اینکه چرا با وجود داشتن برنامه نویسان قوی در ایران، محصولات خوب، کم تولید می شه، بحث دیگه ای است. ببینین، در دنیای نرم افزار، فقط استفاده صحیح از ابزار، عامل موفقیت نیست. متاسفانه در صنعت تولید نرم افزار در ایران، مسئله کار گروهی و مدیریت صحیح در زمینه تولید نرم افزار خیلی کم دیده میشه. من خودم زمانی که در ایران کار می کردم، این مسئله رو بوضوح می دیدم. اما اینجا وضعیت بطور کامل فرق می کنه. در محیط های کاری که من فعالیت کردم، اولین چیزی که توجه منو جلب میکرد، کار گروهی بسیار عالی برنامه نویسان و مدیران پروژه بود. هر کسی در گروه، وظیفه خودشو خوب می دونه و هر عضوی از گروه کار خاصی رو انجام میده. من عامل موفقیت پروژه های نرم افزاری اینجا رو در همین مسئله می دونم، علاوه بر اینکه در اینجا از هر نرم افزاری بصورت بهینه استفاده میشه.

• شما چه زمينه هايی را برای فعاليت دات نت کاران ايرانی پيشنهاد می کنيد؟
خود من علاقه زیادی به XML Web Services و ASP.NET دارم و کاربرد این دو در اینجا زیاده. من به کاربران ایرانی توصیه می کنم که روی این دو زیاد کار کنن. در ضمن توصیه اصلی من روی کار گروهی و مدیریت صحیح پروژه است. برنامه نویسان ایرانی در استفاده از ابزار مشکل خاصی ندارن، ولی متاسفانه کار گروهی و مدیریت صحیح پروژه، نقطه ضعف اصلی صنعت تولید نرم افزار در ایران است.

• چگونه می توان ارتباط کاری بهتری ميان برنامه نويسان داخل و خارج ايجاد نمود؟
بطور کلی اینترنت و بطور خاص وجود سایتهایی مثل سایت IranASP.NET در برقراری ارتباط بین برنامه نویسان ایرانی کمک فراوانی است. بنظر من با فعالتر کردن بخش "سؤال و جواب" میشه این ارتباط رو فنی تر و غنی تر کرد.

IranASP.NET و ديگر هيچ!
• چگونه با سايت IranASP.NET آشنا شديد؟
از طریق یکی از سایتهای ایرانی. اگر درست یادم باشه از طریق سایت "برنامه نویس دات کام" سایت شما رو پیدا کردم.

• اينگونه سايتها چقدر و چگونه می توانند مفيد باشند؟
همونطور که گفتم خاص وجود سایتهایی مثل سایت IranASP.NET در برقراری ارتباط بین برنامه نویسان ایرانی کمک فراوانی می کنه و برای تبادل نظر سایت خیلی مناسبی است. من تقریباً هر روز سایت شما رو می بینم و مقالات جدید رو می خونم.

• چه پيشنهاد، انتقاد يا نظری در مورد IranASP.NET داريد؟
فقط ازتون می خوام که به این راهتون ادامه بدین و این سایت رو فعال نگه دارین. من شخصاً معتقدم که سایت IranASP.NET یکی از بهترین سایتهای فنی ایرانی است که من تا حالا دیدم. مخصوصاً قسمت معرفی سایتهای ایرانی که با NET. ساخته میشن رو خیلی دوست دارم [سايتهای برگزيده]، چون سایتهایی که با NET. ساخته میشن رو می بینم و از کار قشنگشون لذت می برم.

متفرقه!
• برای سيستم عامل ملی کدام يک بهتر است، ويندوز يا لينوکس؟
من شخصاً معتقدم که سایت IranASP.NET یکی از بهترین سایتهای فنی ایرانی است که من تا حالا دیدم. مخصوصاً قسمت معرفی سایتهای ایرانی که با NET. ساخته میشن رو خیلی دوست دارم [سايتهای برگزيده]، چون سایتهایی که با NET. ساخته میشن رو می بینم و از کار قشنگشون لذت می برم.

یک کاربر عادی راحتتر می تونه از Windows استفاده کنه اما Linux هم قابلیتهای زیادی رو ارائه میکنه و سیستم عامل خوبیه. به هر حال، من به عنوان یک برنامه نویس ترجیح خاصی ندارم.

• به سبک مجلات داخل ايران، آبی يا قرمز؟
قرمز.

• الان تب وبلاگ در ايران بالاست، نظرتان در مورد وبلاگ چيست؟
حقیقتش، من خیلی وبلاگ نمی خونم و در موردش نظر خاصی ندارم.

• کدام سايتها را هر روز بايد ببينيد؟
در زمنیه سایتهای فنی، من سایتهای IranASP.NET و iDevCenter.com و MSDN رو تقریباً هر روز میبینم. در زمینه های دیگه هم سایت IranSport.net و BBC رو هر روز نگاه میکنم.

آينده نگری

• آينده IT در ايران را چگونه می بينيد؟
خیلی روشن و خوب! به شرط اینکه قواعد مرسوم در دنیای IT به خوبی در بین اهل IT رعایت بشه. منظورم همون قواعد ساده و در عین حال مهمی است که موفقیت در این زمینه رو تضمین میکنه. کار گروهی، مدیریت صحیح و به روز بودن، از جمله این مسائل است. خوشبختانه، اهل IT در ایران این قابلیت رو دارن و تنها با برنامه ریزی صحیح و کمی همت، میشه به موفقیتهای درخشانتری رسید.

• برنامه آينده شما برای خودتان چيست؟
من فکر کنم تا آخر برنامه نویس باقی بمونم چون این کار رو بی نهایت دوست دارم.

هرچه می خواهد دل تنگت بگو...

• با تشکر از شما که در اين گفتگو شرکت نموديد، در پايان چه صحبتی داريد؟
صحبت که زیاده. خیلی دوست دارم که بتونم به هر صورتی که شده، تجربیات جدیدی که اینجا بدست آوردم رو با برنامه نویسان ایرانی در میان بگذارم. برای تمامی اهل IT در ایران آرزوی موفقیت و سربلندی دارم.

Ali Kheradvar
MCSD.NET, MCAD.NET, MCP
MCP

همه مقالات گفتگو را ببينيد.
جستجو: بگرد!
جستجوی پيشرفته
نام کاربری |
کلمه عبور |


IranASP.NET - Session State در ASP.NET

Session State در ASP.NET

احسان وليزاده | اين مقاله ۵۲۰۶ بار تاکنون ديده شده است.
۱۳۸۲/۹/۳ | برای وبلاگ برای وبلاگ
در این مقاله شئ Session در ASP.NET بررسی می شود.

ASP.NET تنظیمات مدیریت وضعیت پیشرفته ای نسبت به شئ Session در ASP کلاسیک دارد. این تنظیمات در فایل Web.Config پیکربندی می شوند. در این مقاله تنظیمات پیکربندی موجود برای سرویس مدیریت حالت و رویدادهایی که می توانند در فایل Global.asax اداره شوند و همچنین مثالهایی از استفاده شئ Session برای برقراری وضعیت را بررسی خواهیم کرد.

پیکربندی Session
وضعیت جلسه يا Session State می تواند در قسمت <SessionState> فایل Web.Config پیکربندی شود. قطعه کد زیر که از یک فایل Web.Config انتخاب شده است صفاتی که می تواند به این قسمت اختصاص داده شود را نشان می دهد:

<sessionState
mode="Off|InProc|StateServer|SqlServer"
stateConnectionString="tcpip=127.0.0.1:42424"
sqlConnectionString="data source= 127.0.0.1;userid=sa;password="
cookieless="true|false"
timeout="20"
/>

صفت | توضیح
mode | بیان می کند که وضعیت جلسه (Session State) در کجا ذخیره شده است. مقادیر مجاز عبارتند از : Off ( وضعیت حالت خاموش است) – Inproc ( در حافظه ) - StateServer ( حافظه سرور ) – SqlServer ( در پایگاه داده ).
stateConnectionString | رشته ارتباط به سرور مدیریت حالت. این صفت زمانی استفاده می شود که صفت mode برابر SqlServer است.
sqlConnectionString | رشته اتصال به پایگاه داده مدیریت جلسه. این صفت زمانی استفاده می شود که صفت mode برابر SqlServer است.
cookieless | این صفت یک مقدار Boolean می گیرد و به سایتها اجازه می دهد کاربران آنها از کوکی ها به خاطر بهره گیری از مزایای Session State در ASP.NET استفاده نکنند.
timeout | نشان دهنده دقایقی است که یک جلسه بیکار خاتمه می یابد. پیش فرض 20 دقیقه است.

رویدادهای Session
دو رویداد مربوط به شروع و خاتمه جلسات در فایل Global.asax وجود دارند که می توانید آنها را اداره کنید. این رویدادها Session_Start و Session_End نام دارند. مثلا به کمک آنها می توان تعداد کاربران آنلاین وب سایت را در صفحه نشان داد. برای این کار باید در رویداد Session_Start یک واحد به تعداد کاربران آنلاین اضافه کنیم و یک واحد از این تعداد را در رویداد Session_End کم کنیم. کد زیر نحوه تعریف کردن رویدادها را در فایل Global.asax نشان می دهد:

<script language="VB" runat="server">

Sub Session_Start(sender As Object, e As EventArgs)

End Sub

Sub Session_End(sender As Object, e As EventArgs)

End Sub

</script>

استفاده از شئ Session
شئ Session در واقع یک خصوصیت کلاس Page و همچنین یک نمونه از کلاس HttpSessionState است که در فضانام System.Web.SessionState تعریف شده است. استفاده از شئ Session همانند استفاده از یک مجموعه (Collection) است. مثال زیر نام کاربر را به یک متغیر Session در رویداد Page_Load اختصاص می دهد و سپس از آن متغیر برای خوش آمد گویی به کاربر استفاده می کند. صفحات دیگر نیز می توانند آن نام را برای فراهم کردن صفحات شخصی از Session دریافت کنند.

<%@ Page Language="VB" %>
<script language="VB" runat="server">
Sub page_load()

Session["name"] = "James";

End Sub
</script>

<HTML>
<body>
Hello <%=Session["name"]%>!
</body>
</HTML>

همه مقالات کليات ASP.NET را ببينيد.
جستجو: بگرد!
جستجوی پيشرفته
نام کاربری |
کلمه عبور |


IranASP.NET - فرم Login

فرم Login

مهناز غلامی | اين مقاله ۷۵۴۳ بار تاکنون ديده شده است.
۱۳۸۲/۹/۳۰ | برای وبلاگ برای وبلاگ
تعريف فرمی جهت ورود به صفحات قابل دسترسی (User Authentication)

فرم ورودی شامل کنترلهای زير است:

BtnCancel TxtUserName TxtPassword BtnSubmit

زيربرنامه ای بنام check تعريف می کنيم:

Public Sub check()
Dim strConn As String = "server=localhost;uid=;pwd=;database=mydb;"

پس از گرفتن Connection به تعريف SqlCommand و DataReader می پردازيم:

Dim MyConn As New System.Data.SqlClient.SqlConnection(strConn)
Dim objDR As System.Data.SqlClient.SqlDataReader

حال متغيری از نوع رشته ای را برای انتخاب فيلدهای جدولمان تعريف می کنيم:

Dim MySQL As String = "Select username, password from login Where username = '" & TxtUserName.Text & "' and password = '" & TxtPassword.Text & "'"
Dim Cmd As New System.Data.SqlClient.SqlCommand(MySQL, MyConn)
MyConn.Open()
objDR = Cmd.ExecuteReader(System.Data.CommandBehavior.CloseConnection)

سپس DataReader بر اساس cmd تعريف شده Excute می شود حال بايد بررسی کنيم که همچنين کاربری در جدول login وجود دارد يا نه؟ اگر کاربری با مشخصات ارسالی وجود نداشته باشد پيغامی به کاربر مبنی بر نادرست بودن اطلاعات ورودی داده می شود:

If Not objDR.Read() Then
Response.Write("<script>alert('Username or password is invalid!');location.href='loginadmin.aspx'</script>")
Response.End()
TxtUserName.Text = ""
TxtPassword..Text = ""
objDR.Close()
MyConn.Close()
Else
Session("password") = objDR("password")
Response.Redirect ("IndexAdmin.aspx")

در غير اين صورت به صفحه مربوطه انتقال داده می شود و در آخر objdr و MyConn را close می کنيم. لازم به ذکر است که در صفحه ارجاعی در قسمت Page_Load دستور زير که نشان دهنده کلمه عبور صحيح است نوشته شود:

If Session("password") = "" Then
Response.Write("<script>alert('You must be Login!');location.href='loginadmin.aspx'</script>")
Response.End()
Response.Redirect("loginadmin.aspx")
End If

همه مقالات ADO.NET و پايگاه داده را ببينيد.
جستجو: بگرد!
جستجوی پيشرفته
نام کاربری |
کلمه عبور |


IranASP.NET - آمار کاربران سايت در ASP.NET

آمار کاربران سايت در ASP.NET

رسول هاجری | اين مقاله ۶۱۶۰ بار تاکنون ديده شده است.
۱۳۸۲/۱۰/۸ | برای وبلاگ برای وبلاگ
روزانه کاربران زيادی از سايت شما بازديد می کنند و برای هر مدير سايت آمار بازديدها، صفحات بازديد شده، ساعت و تاریخ بازديد، لينک و سايتی که کاربر به واسطه آن از سايت ما بازديد نموده است و . . . از اهميت ويژه‌ای برخوردار است.

روزانه کاربران زيادی از سايت شما بازديد می کنند و برای هر مدير سايت آمار بازديدها، صفحات بازديد شده، ساعت و تاریخ بازديد، لينک و سايتی که کاربر به واسطه آن از سايت ما بازديد نموده است و . . . از اهميت ويژه‌ای برخوردار است.

برای آمارگيری از سايت‌ها از روشهای مختلفی می توان استفاده نمود:

۱- استفاده از سايتهای آمارگيری رايگان همانند: Nedstat يا Sitemitter و . . .
۲- به روش برنامه‌نویسی و بررسی از داخل برنامه

در روش اول به نوعی برای نمايش به کاربران از اعتبار بيشتری برخوردار است اما نقص آن علاوه بر تبليغ مجانی برای ديگران اين است که در بعضی از Firewallها به اسکريپتی که اطلاعات کاربر را به اين سايتها ارسال می نمايد همانند يک تروجان (اسب تراوا يا سيستم جاسوسی) نگاه می کنند و اجازه عبور به آن نمی دهند.

به همين خاطر روش دوم می تواند دقیق تر عمل نمايد. از سوی ديگر ذخيره اطلاعات کاربران در يک بانک اطلاعاتی می تواند منشأ گزارشات بسيار جالبی برای مديران سيستم شود.

در نمونه برنامه زير سعی کرده‌ام اطلاعات نسبتاً جالبی از رفتار کاربران به کمک ASP.NET را به نمايش گذارم. البته مطالب ذيل نمونه‌ای از اطلاعات کاربران سايت می باشد که می شود به سليقه و نياز خودتان آنرا تغيير دهيد (کليه متغيرهايی که نوع آنها ذکر نشده است از نوع String می باشد).

الف) نام دستگاه کاربر و IP آن

ClientName = Request.UserHostName
ClientIP = Request.UserHostAddress

ب) لينکی که کاربر با کليک بر روی آن سايت را يافته است.

REFERER = Request.ServerVariables.Item("HTTP_REFERER")

ج) اطلاعاتی در رابطه با سیستم کاربر (Client)

LANGUAGE = Request.ServerVariables.Item("HTTP_ACCEPT_LANGUAGE")
AGENT = Request.ServerVariables.Item("HTTP_USER_AGENT")
Platform = Request.Browser.Platform()

د) QUERY STRING صفحه حاضر

QUERY STRING = Request.ServerVariables.Item("QUERY_STRING")

ح) اطلاعاتی در رابطه با Browser کاربر

Browser = Request.Browser.Browser()
Browser_Type = Request.Browser.Type()
Browser_Version = Request.Browser.Version()

ز) زمان و تاريخ بازديد

Dim MyDateTime As New DateTime
MyDateTime = Now()
Dim MyDate As String = MyDateTime.ToString("MM/dd/yyyy")
Dim MyTime As String = MyDateTime.ToString("hh:mm:ss")

بديهی است در صورتی که بخواهيم به محض ورود کاربر به سايت اين مجموعه اطلاعات را جمع‌آوری نماييم، می بايست آن را در زيربرنامه Session_Start انجام دهيم (اين روتين در Global.asax قرار دارد).

با ارسال محتويات اين متغيرها به بانک اطلاعاتی می توان گزارشاتی از جمله تعداد بازديدها در مقاطع زمانی مختلف، صفحات پر بيننده، پر بيننده‌ترين صفحه امروز و. . . را استخراج نمود.

همه مقالات کليات ASP.NET را ببينيد.
جستجو: بگرد!
جستجوی پيشرفته
نام کاربری |
کلمه عبور |


IranASP.NET - کارکردن با رشته‌ها و متن‌ها در ASP.NET

کارکردن با رشته‌ها و متن‌ها در ASP.NET

رسول هاجری | اين مقاله ۴۶۹۰ بار تاکنون ديده شده است.
۱۳۸۲/۱۰/۲۷ | برای وبلاگ برای وبلاگ
اغلب متن‎هايی که کاربران يک سايت توسط فرم‌ها ارسال می‌کنند و يا اطلاعاتی که از يک بانک دريافت می‌شود، نياز به بررسی و يا اعمال تغييرات دارند. در اين مقاله با برخی توابع و امکانات ASP.NET برای کارکردن با رشته‎ها يا به تعبيری ديگر string‎ها آشنا می شويم.

اغلب متنهايی که کاربران يک سايت توسط فرم‌ها ارسال می‌کنند و يا اطلاعاتی که از يک بانک دريافت می‌شود، نياز به بررسی و يا اعمال تغييرات دارد.

خوشبختانه ASP.NET مجموعه امکانات بسيار خوبی برای کارکردن با رشته‌ها ارائه نموده است. بعبارت ديگر با استفاده از کلاس String برای ذخيره متون در برنامه، امکانات زيادی را برای کار کردن با رشته‎های حرفی خواهيم داشت.

در مثال‌های زير سعی کرده‌ام مهمترين و پرمصرف‌ترين دستورات کار با رشته‌ها را معرفی کنم.

الف) انتخاب قسمتی از متن (mid)
دستور mid بر اساس فرم زير قابل استفاده است:

Mid(A, B, C)

A = متغير متنی يا يک رشته متن

B = شماره کارکتر شروع انتخاب

C = تعداد کارکتر انتخاب

Dim aString As String = "SomeString"
Dim bString As String
bString = Mid(aString, 3, 3) ' Returns "meS"
Response.Write(bString)

ب) انتقال بخشی از يک متن به داخل يک متغير
Substring بر اساس روش زير قابل استفاده می باشد:

نام متغير رشته‌ای.Substring(A, B)

A = شماره کارکتر شروع انتخاب

B = تعداد کارکتر انتخاب

Dim aString As String = "A String"
Dim bString As String
bString = aString.Substring(2, 6) ' Returns "String"
Response.Write(bString)

ج) جمع نمودن چند رشته با يکديگر
String.Concat می‌تواند چند رشته را در کنار هم قرار دهد و يا مجموع اطلاعات يک آرایه را با هم ادغام نمايد.

Dim myString As String
Dim aString(10) As String
Dim t As Integer
For t = 0 To 9
aString(t) = CStr(t)
Next t

myString = String.Concat(aString) ' Returns "0123456789"
Response.Write(myString)

د) ادغام رشته‌ها به همراه قرار دادن کارکتر جدا کننده
String.Join اين امکان را فراهم می‌کند تا ضمن ادغام چند رشته، در بين اطلاعات کاراکتر جداکننده نيز قرار دهيم.

Dim shoppingItem(2) As String
Dim shoppingList As String
shoppingItem(0) = "Milk"
shoppingItem(1) = "Eggs"
shoppingItem(2) = "Bread"
shoppingList = String.Join(",", shoppingItem) 'Returns "Milk,Eggs,Bread"
Response.Write(shoppingList)

ح) اضافه کردن متن جدید به يک رشته (Insert)
برای اضافه کردن متن جدید به يک رشته کافی است از Insert به روش زير استفاده نماييم:

متغير رشته‌ای.Insert(A, B)

A = شماره کارکتری که اضافه شدن از آن شروع می‌شود

B = متنی که می‌خواهيم اضافه کنيم

Dim aString As String = "This is My Stng"
Dim myString As String
myString = aString.Insert(13, "ri") ' Returns "This is My String"
Response.Write(myString)

و) جدا نمودن يک رشته بر اساس يک کارکتر تکراری
گاهی اوقات لازم است بر خلاف String.Join متن يک رشته را که به طور مثال با "،" به قطعات مشخص تقسيم شده است را از هم جدا نماييم. برای اين منظور همانند مثال زير عمل نماييد:

Dim shoppingList As String = "Milk,Eggs,Bread"
Dim shoppingItem(2) As String
shoppingItem = shoppingList.Split(","c)
Dim s As String
For Each s In shoppingItem
If s.Trim() <> "" Then
Response.Write(s & "<BR>")
End If
Next s

ز) جایگزينی متن در رشته (Replace)
هرگاه نياز به تعويض و جايگزينی يک متن در يک رشته داشته باشيم می‌توانيم از Replace همانند مثال استفاده کنيم:

Dim myString As String = "Shopping List"
Dim aString As String
aString = Replace(myString, "o", "i") ' Returns "Shipping List".
Response.Write(aString)

همه مقالات کليات ASP.NET را ببينيد.
جستجو: بگرد!
جستجوی پيشرفته
نام کاربری |
کلمه عبور |


IranASP.NET - فايل Web.Config را بهتر بشناسيم

فايل Web.Config را بهتر بشناسيم

کيوان نيّری | اين مقاله ۵۰۷۵ بار تاکنون ديده شده است.
۱۳۸۲/۱۱/۱۹ | برای وبلاگ برای وبلاگ
بيشتر برنامه‎های کامپيوتری تنظيمات خاص خود را در قالب مفهومی بنام Setup نگهداری می‎کنند. برنامه‎های ASP.NET هم از اين قاعده مستثنی نيستند و می‎توان کليه تنظيمات وب سايت را در قالب يک فايل از جنس XML بنام Web.Config نگهداری کرد.

مقدمه
بيشتر برنامه های کاربردی کامپيوتری دارای بخشی به نام Setup هستند که برای انجام تنظيمات متناسب با استفاده های مختلف کاربران مورد استفاده قرار می گيرد. برنامه های کاربردی مبتنی بر Web نيز که دارای کاربران زيادی هستند از اين قائده مستثنی نيستند و احتياج به انجام تنظيماتی متناسب با کاربردهای مختلف خود دارند.

در ASP.NET اينگونه تنظيمات که مربوط به منابع مورد استفاده برنامه کاربردی، اطلاعات محلی، اطلاعات امنيتی و... می شوند در داخل يک فايل XML ذخيره می شوند که نام آن Web.Config است و طبعا به مانند اسناد XML شامل تعدادی تگ (معادل Tag در HTML) است و به کوچک و بزرگ بودن حروف نيز حساس است (Case Sensitive).

در اين مقاله به اختصار به توضيح در مورد تگهای مهم اين فايل و چگونگی تنظيم خصوصيات مهم اين تگها و کاربردهای آنها می پردازيم. پيش از ادامه مطلب اين نکته را متذکر می شويم که اين فايل شامل تعداد زيادی تگ با خصوصيات مختلف است که هر يک به جنبه ای از يک برنامه کاربردی تحت Web مربوط هستند. در اين مقاله در مورد تگهای پرکاربرد و مهم اين فايل و خصوصيات مهم آنها اطلاعاتی ارائه شده است برای به دست آوردن اطلاعات بيشتر در مورد هر يک از تگها و خواص آنها بايد به منابع تخصصی مرتبط با هر بخش رجوع کرد.

محل و محدوده عملکرد فايل Web.Config
به طور طبيعی هر برنامه کاربردی Web در ASP.NET دارای حداقل يک فايل Web.Config در داخل دايرکتوری ريشه خود می باشد که به طور خودکار توسط Visual Studio .NET در زمان ايجاد اين Web Application ايجاد شده و با مقادير پيش فرض در دايرکتوری ريشه برنامه کاربردی قرار می گيرد. ولی برنامه نويسان می توانند بر حسب نيازها و کاربردهای برنامه های خود تعداد بيشتری از اين فايل XML را در داخل دايرکتوريهای مختلف برنامه ايجاد کنند و برای تنظيمات فايلهای داخل همان دايرکتوری يا زير دايرکتوريهای آن به کار گيرند.

تنظيمات هر فايل Web.Config به فايلهای داخل زير دايرکتوری‎ای که در آن قرار دارد و همچنين زير دايرکتوريهای آن اعمال می شود. همچنين برنامه نويس می تواند از طريق کدهای داخل هر فايل Web.Config منابع و دايرکتوريهای مورد نظر را تغيير دهد. برای درک بهتر نحوه ارتباط فايلهای Web.Config در يک برنامه کاربردی Web، مثال زير را بيان می کنيم.

اگر يک دايرکتوری به نام main و دو زير دايرکتوری به نام Sub1 و Sub2 در برنامه کاربردی موجود باشند که در درون هر کدام از اين دايرکتوريها يک فايل Web.Config قرار داشته باشد تنظيمات هر فايل Web.Config بر فايلهای داخل زير دايرکتوری آن اعمال می شود اما اگر در يک فايل Web.Config که داخل زير دايرکتوری Sub1 يا Sub2 قرار دارد يکی از تنظيماتی که در فايل Web.Config که داخل main قرار دارد صورت نگرفته باشد مقدار تنظيم شده در داخل فايل موجود در main به زيردايرکتوريها به ارث می رسد.

نکته ای که بايد در اينجا به آن اشاره کرد اين است که کاربران برنامه وب به محتوای فايلهای Web.Config دسترسی ندارند.

ساختار فايل Web.Config
هر فايل Web.Config شامل يک بخش پايه است که همان دو تگ <configuration> و<configuration/> هستند و بقيه محتوا درون اين دو تگ قرار می گيرد. پس ساختار کلی هر فايل Web.Config به صورت زير است:

<configuration>
<!--Some Configurations-->
</configuration>

محتوای هر فايل Web.Config شامل دو بخش اساسی است: معرفی و تنظيمات. بخش معرفی داخل دو تگ <configsectons> و <configsections/> قرار می گيرد و بخش تنظيمات، تنظيمات مربوط به منابع معرفی شده در اين تگها را شامل می شود.

ابتدای فايل Web.Config و بعد از تگ <configuration> تگ <configsections> قرار دارد. داخل اين تگ و تگ جفت آن يعنی <configsectons/> تگهايی جهت معرفی منابع و اداره کننده قسمتها قرار دارد. حال که با ساختار کلی فايل Web.Config آشنا شديم در ادامه به توضيحاتی در مورد تگهای مهم اين فايل و خصوصيات آنها می پردازيم.

Location
پيشتر اشاره شد که تنظيمات هر فايل Web.Config بر فايلهای داخل ريشه اين فايل و زيردايرکتوری های آن اعمال می شوند، حال اگر بخواهيم تنظيمات يک فايل Web.Config را بر دايرکتوری خاصی اعمال کنيم تنها لازم است اين تنظيمات را داخل يک جفت تگ <location> و <location/> قرار دهيم يعنی شکل کلی استفاده از اين جفت تگ به صورت زير است:

<location path="url">
<!--Configurations-->
</location>

اطلاعات محلی
از تگ <globalization> برای تعريف خصوصيات فرهنگی و زبانی برنامه کاربردی استفاده می شود. خواص مهم اين تگ عبارتند از:

• culture: فرهنگ برنامه کاربردی را تعيين می کند.
• requestencoding: شکل رشته های درخواست شده را تعيين می کند (برای مثال Unicode).
• responseencoding: شکل رشته های پاسخ را تعيين می کند.

تگهای امنيتی
درون فايل Web.Config تگهايی جهت تنظيم مقادير و خصوصيات امنيتی برنامه کاربردی قابل تعريف هستند. جفت تگهای <authentication> و<authentication/> و <authorization> و<authorization/> ساختارامنيتی درون فايل Web.Config را می سازند که دارای خصوصيات و مقادير متفاوتی هستند که توضيح در مورد آنان به مباحث مقدماتی امنيت در ASP. NET بر می گردد ولی در زير توضيح کوتاهی از هر يک از اين جفت تگها ارائه می گردد.

تگ <authentication>: اين جفت تگ به تعيين شکل تاييد اعتبار در برنامه کاربردی تحت Web می پردازد. از طريق خصوصيت mode که چهار مقدار Form ،Passport ،Windows و None را می پذيرد می توان شکل تاييد اعتبار را به ترتيب بر مبنای ساختار امنيتی IIS، سرويس تاييد اعتبار Passport شرکت مايکروسافت، استفاده از cookieها و بدون استفاده از سيستم امنيتی تعيين کرد.

تگ <authorization>: اين جفت تگ برای تعيين کاربران واجد شرايط و يا فاقد شرايط ورود به محدوده تحت کنترل فايل Web.Config استفاده می شود. با استفاده از دو تگ <allow> و <deny> می توان کاربرانی که اجازه ورود به محدوده تحت حفاظت را دارند و فاقد اين اجازه هستند استفاده کرد.

خطای زمان اجرا
تگ <customerrors> جهت تعيين شکل عملکرد برنامه در زمان وقوع يک خطای پيش بينی نشده در زمان درخواست يک صفحه توسط کاربر به کار می رود. اين تگ دارای دو صفت مهم است که در زير توضيح داده شده اند.

• mode: اين صفت جهت تعيين نوع عملکرد برنامه کاربردی در مواجهه با خطا به کار می رود و يکی از سه مقدار RemoteOnly ،On و Off را می گيرد. با تنظيم اين صفت با مقدار RemoteOnly در صورت بروز خطای زمان اجرا صفحه از پيش تعيين شده در قسمت defaultredirect برای کاربران نشان داده خواهد شد ولی کاربرانی که بصورت محلی از برنامه استفاده می کنند (مقابل سرور نشسته اند) صفحه خودکار ASP.NET و جزئيات خطا را خواهند ديد. با تنظيم اين صفت با مقدار On در صورت بروز خطای زمان اجرا همواره صفحه از پيش تعيين شده در قسمت defaultredirect نشان داده خواهد شد. با تنظيم اين صفت با مقدار Off صفحه خطای خودکار ASP. NET به نمايش در می آيد که از لحاظ امنيتی گزينه مناسبی نيست.

• defaultredirect: آدرس Url فايلی را که برای نمايش خطا در زمان تنظيم خصوصيت mode با مقدار On يا RemoteOnly بکار می رود تعيين می کند.

وضعيت جلسه کاری
تگ <sessionState> برای تعيين وضعيت جلسه کاری مورد استفاده قرار می گيرد و مدت زمان يک جلسه کاری و همچنين شکل تعيين درخواست کاربران را تعيين می کند. از صفات مهم اين تگ يکی Cookiless است که تعيين می کند جلسه کاری کاربران از طريق Cookieها يا SessionID ها نسبت داده شوند که دو مقدار true يا false را می گيرد: true برای استفاده از SessionID و false برای استفاده از Cookie.

خصيصه مهم ديگر اين تگ mode است که يکی از چهار مقدار زير را می گيرد:

• Off: جلسه کاری غير فعال
• Inproc: اطلاعات به صورت In-process ذخيره می شوند.
• SQLServer: اطلاعات جلسه کاری توسط پايگاه داده SQL Server مديريت می شوند.
• StateServer: اطلاعات توسط يک سرويس Out-Of-Process مديريت می شوند.

خصوصيت مهم ديگر اين تگ timeout است که زمان اعتبار جلسه کاری هر کاربر را بر حسب دقيقه تعيين می کند.

کامپايل برنامه کاربردی
تگ <compilation> برای تعيين خصوصيات مربوط به شکل کامپايل برنامه کاربردی مورد استفاده قرار می گيرد که دو خصيصه مهم آن عبارتند از:

• debug: يکی از دو مقدار true يا false را می گيرد (false پيش فرض است) و تعيين می کند که اطلاعات اشکال زدايی در اسمبلی های بعد از کامپايل قرار بگيرند يا خير. با تنظيم اين خصيصه با مقدار true اين کار صورت می گيرد. و با تنظيم اين خصيصه با مقدار false اين کار صورت نمی گيرد.
• defaultlanguage: زبان برنامه نويسی مورد استفاده جهت کامپايل برنامه کاربردی (به صورت Dynamic) را تعيين می کند.

همه مقالات کليات ASP.NET را ببينيد.
جستجو: بگرد!
جستجوی پيشرفته
نام کاربری |
کلمه عبور |


IranASP.NET - IrMail، روشی جديد برای ارسال نامه در ASP.NET (بخش اول)

IrMail، روشی جديد برای ارسال نامه در ASP.NET (بخش اول)

محمود مروج | اين مقاله ۵۶۶۳ بار تاکنون ديده شده است.
۱۳۸۲/۱۲/۴ | برای وبلاگ برای وبلاگ
ارسال نامه از طريق سايت بصورت خودکار همواره برای برنامه نويسان وب موضوعی حساس و مهم بوده است. بسياری از بخش های يک سايت حرفه‎ای مانند صفحه ارتباط با مدير سايت، نامه‎های يادآوری کلمه رمز کاربران، ارسال خبرنامه و... همگی به نوعی از قابليت ارسال نامه توسط يک برنامه بهره می برند. اين مقاله به معرفی يک شئ جديد بنام IrMail جهت ارسال نامه در ASP.NET با تاکيد بر زبان فارسی می پردازد.

تذکر ۱: هر جا در اين مقاله کلمه "شئ IrMail" ذکر شود، منظور همان کامپوننت آن (IrMail Component) است که به منظور رساندن مطلب، از اين جايگزين استفاده شده است.
تذکر ۲: شئ IrMail صرفاً برای نسخه NET 1.1. (و به بعد) طراحی شده است. برای نسخه NET. 1.0، با نويسنده مقاله تماس بگيريد.

مطلب را با طرح يک مساله آغاز می کنيم و در ادامه آن به بررسی و يافتن راه حل های مختلف برای آن و مقايسه آنها با هم می پردازيم.

طرح مساله

همانطور که می دانيد يکی از مسائلی که برنامه نويسان برنامه های تحت وب (web applications) با آن مواجه هستند، مساله ارسال نامه از طريق سايت به صورت خودکار می باشد. دلايل نياز به انجام چنين کاری را می توان به صورت زير خلاصه کرد:

• ايجاد صفحه "تماس با ما" و امکان ارسال نامه از طريق سايت
• نامه های حاوی اطلاعات کاربر برای تاييد عضويت
• نامه های يادآوری Password کاربران
• خبرنامه ها
• و در کل هرگونه نياز به ارتباط با کاربر از طريق ايميل به صورت پويا و خودکار

ASP.NET در مقابل ASP کلاسيک

اگرچه شئ CDONTS به شکل استفاده از يک شئ جنبی اين مساله را در ASP کلاسيک تا حدی حل کرده بود، اما کاربران ASP کلاسيک بصورت عمده با اين مساله مواجه بودند. اين مساله به حدی مهم بود که يکی از مشخصه های اصلی انتخاب يک ميزبان (host) مناسب برای ميزبانی سايت‎هايشان را همين موضوع در برمی گرفت. بطوريکه تا قبل از تست امکانات آن و مطمئن شدن از آن اقدام به بستن قرارداد نمی کردند و يا در نهايت اقدام به تعويض ميزبان مورد نظر می کردند.

با پيدايش NET Framework. عملاً اين مشکل حل شد. چرا که:

• وجود شئ‎ ‎ای بصورت ذاتی برای اين کار
• امکان ارث بری از کلاسها
• و عدم نياز به ثبت شدن اسمبلی ها (Dll) در Registry

اين مساله بسياری از توانايی ها و امکانات را در دست برنامه نويسان قرار داد تا حتی در صورت ناقص بودن کلاس های موجود در NET.، امکان تکميل و حتی ارايه يک کلاس جديد در اين زمينه را داشته باشند.

در ASP کلاسيک از آنجا که اشياء بايد در رجيستری ثبت گردند، عملاً اين امکان را از بسياری از برنامه نويسان عادی سلب می کرد که خود بر روی اشياء کار کنند و نمونه مورد نظر را ايجاد و استفاده نمايند. دليل اين بود که اکثر ميزبانها حاضر به رجيستر کردن شئ شما نيستند و به اين ترتيب انحصار کار بر روی اين اشياء برای يک سری شرکتها بدست آمده بود.

اما در NET. با توجه به نکاتی که گفته شد اين انحصار از بين رفت و بسياری از برنامه نويسان عادی نيز اقدام به تهيه اشيائی دراين زمينه کردند بطوريکه در سايت رسمی ASP.NET نيز مکانی برای جمع آوری و معرفی اشيا معرفی شده توسط کاربران فراهم آمد. اين اشيا از طريق آدرس http://www.asp.net/ControlGallery/default.aspx?tabindex=2 قابل مشاهده و حتی دريافت مجانی هستند.

مشکلات شئ موجود در NET.

اما چه مساله‎ای باعث شد که برنامه نويسان NET. اقدام به تکميل ويا ايجاد شئ جديدی در اين زمينه کنند؟ همانگونه که راهنمای NET. بيان کرده است، در حقيقت کلاس SmtpMail بصورت يک لفاف يا اصطلاحاً يک wrapper برای کلاس Collaboration Data Objects for Windows 2000 (CDOSYS) می باشد. در واقع اين لفاف تنها قابليتهای ساده‎ای از اين شئ قدرتمند را پشتيبانی کرده است و بسياری از امکانات آن در صورت استفاده از اين لفاف ديگر قابل استفاه نيست. بعنوان مثال هنگامی که سرويس دهنده SMTP شما نياز به شناسائی (Authentication) دارد، SmtpMail هيچ امکانی جهت تعيين نام کاربری و کلمه رمز به شما نمی دهد. همچنين شما نمی توانيد charset را برای نامه ارسالی خود در حالت HTML تعيين کنيد. بعبارت ديگر شئ SmtpMail بسيار ساده و ابتدائی است. ولی ما در برخی مواقع نياز داريم که قابليتهای بيشتری از CDOSYS را در اختيار بگيريم و از آنها استفاده کنيم.

توجه : در اين مقاله به نحوه کار شئ موجود در NET Framework. پرداخته نمی شود. مقاله های مربوط به کار با اين شئ از همين سايت قابل دريافت است.

همين دو مورد و بالاخص مورد اول بسياری از برنامه نويسان را بر آن داشت که به دنبال راهی برای رفع اين مشکلات باشند. از جمله اين تلاش ها مقاله ای است که قبلاً در همين سايت انتشار يافته است. همان مقاله مرا بر آن داشت تا به تکميل آن اقدام کرده و آنرا در شکلی مناسب تر و قابل استفاده تر ارايه نمايم.

قبل از آنکه به بيان مزايا و توانايی های شئ IrMail بپردازيم، ابتدا با اشاره ای کوتاه، يکی ديگر از معضلات ارسال نامه را بررسی می کنيم.

مشکل ارسال ايميل به زبان های غير انگليسی

اين مشکل نيز از جمله مشکلاتی است که گريبانگير بسياری از سايت های غير انگليسی زبان است. مشکلی که قبل از آنکه به اشيا ارسال نامه مربوط باشد، به عدم وجود استانداردهای لازم در اين زمينه بر می گردد. استانداردهايی که هم مرورگرها ملزم به پشتيبانی از آن باشند و هم سرويس دهندگان ايميل (منظور آنکه اين مشکل به NET. ارتباطی ندارد).

در اين مقاله به جای استفاده از کلمه "غيرانگيسی"، از نمونه ای از زبانهای غير انگليسی که اينجا فارسی است استفاده می شود. توجه کنيد هرکجا که از زبان فارسی نام برده شد، منظور هر زبان غيرانگليسی است که به عنوان نمونه ای از آن مطرح می شود.

اين مشکل از آنجا شروع شد که برخی از برنامه نويسان قصد داشتند نامه های خود را به زبان فارسی ارسال کنند. برنامه نويسان بطور عمده برای حل اين مشکل سه راه حل را درپيش داشتند:

• ارسال نامه به زبان انگليسی
• ارسال تصويری از متن فارسی
• و يا نهايتا به صورت پينگليش (برای فارسی زبانان)!

در هر سه روش مورد استفاده، عملا مشکل به صورت کامل حل نشد.

آنهايی که قصد ارسال نامه به زبان انگليسی را داشتند با طيف گسترده کاربران غير انگليسی زبان مواجه می شدند و اين در حالی بود که نوشتن خود نامه به زبان انگليسی از ديگر مشکلات بود. در کل نيز ارسال نامه به زبانی غير از زبان سايت بی سنخيت است. مانند آنکه اداره شما در ايران باشد و کليه روابط آن بر اساس زبان فارسی و اين در حاليکه کليه مکاتبات شما به زبان انگليسی صورت گيرد.

در روش ارسال عکس متن، که ديگر کمتر مورد استفاده است، نيز به دليل حجم بالای نامه و عدم انعطاف پذيری آن (و اين روزها وجود ويروس و ...) برای سايت های رسمی و حتی کاربران قابل قبول نيست. ضمن آنکه امکان ايجاد عکس های پويا که فرم مناسبی هم داشته باشند کار سخت و طاقت فرسايی است.

در روش سوم اصل عمل مشکل دارد و بيشتر شبيه شوخی است! شوخی ای که به دليل عدم آشنايی کاربران به زبان انگليسی و اينکه سرويس های کامپيوتری بطور عمده به زبان انگليسی است، به يک جديت تلخ تبديل شده است. به هر حال استفاده از اين روش برای سايتهايی که عملکرد آنها رسمی و جدی است بی معنی و نامناسب است. اين روش شايد تنها مورد استفاده سايت های فانتزی و غير رسمی باشد.

در اين ميان برخی نيز تصميم گرفتند که نامه های خود را به زبان فارسی ارسال کنند و در همان نامه به انگليسی (يا پينگليش!) نحوه خواندن نامه به فارسی را ذکر می کردند. چراکه در اکثر مواقع اگرچه نامه فارسی بود ولی در مقصد فارسی ديده نمی شد ونياز به اعمال روش هايی بود که شخص قادر باشد نامه را به فرم صحيح فارسی ببيند. اگرچه اين روش نيز هم اکنون مرسوم است، اما باز هم طيف وسيعی از کاربران عادی نيز با اين مورد مشکل دارند.

چرا IrMail مطرح شد؟

شما در اين مقاله با دلايل نياز به يک شئ ارسال نامه آشنا شديد و اهميت وجود آنرا برای يک برنامه تحت وب ديد. سپس روش ها و ابزارهای آماده ای که مايکروسافت در اين راستا در اختيار برنامه نويسان قرار داده بود را بررسی نموديم (البته تا نسخه NET 1.1.). سپس اشاره ای داشتيم به توانايی NET. در رفع اين مشکل (اما توسط خود کاربران). نهايتا موضوع ارسال نامه های غير انگليسی زبان و روشهای کنونی مواجه با آنرا بررسی کرديم.

هم اکنون به شئ IrMail رسيديم. اينکه چرا تصميم بر آن شد که شئ‎ای برای ارسال نامه ايجاد شود، دقيقا به همان دلايل بالا و چند مورد ديگر است. بطوريکه مشکلات فوق در اين شئ تا حد زيادی برطرف شد. در بخش پايانی اين مقاله شئ IrMail را به طور کامل معرفی و مزيت های آن به طور کامل شرح داده خواهد شد.

قسمت دوم

همه مقالات کليات ASP.NET را ببينيد.
جستجو: بگرد!
جستجوی پيشرفته
نام کاربری |
کلمه عبور |


IranASP.NET - IrMail، روشی جديد برای ارسال نامه در ASP.NET (بخش دوم)

IrMail، روشی جديد برای ارسال نامه در ASP.NET (بخش دوم)

محمود مروج | اين مقاله ۵۴۰۴ بار تاکنون ديده شده است.
۱۳۸۲/۱۲/۱۳ | برای وبلاگ برای وبلاگ
ارسال نامه از طريق سايت بصورت خودکار همواره برای برنامه نويسان وب موضوعی حساس و مهم بوده است. بسياری از بخش های يک سايت حرفه‎ای مانند صفحه ارتباط با مدير سايت، نامه‎های يادآوری کلمه رمز کاربران، ارسال خبرنامه و... همگی به نوعی از قابليت ارسال نامه توسط يک برنامه بهره می برند. اين مقاله به معرفی يک شئ جديد بنام IrMail جهت ارسال نامه در ASP.NET با تاکيد بر زبان فارسی می پردازد.

در قسمت قبل اين مقاله به بررسی نياز به شئ ‎ای برای ارسال نامه ها در برنامه های تحت وب پرداختيم. همچنين نگاهی داشتيم به روشها و امکانات موجود در اين زمينه. نهايتا به اينجا رسيديم که ابزارهای حاضر کامل نيستند و نياز به تکميل دارند. در صورتيکه قسمت قبل اين مقاله را مطالعه نکرده ايد، پيشنهاد می شود قبل از ادامه به خواندن اين قسمت، آنرا مطالعه فرمايد.

همانطور که اشاره شد، شئ IrMail شئ‎ای است برای ارسال نامه ها از طريق برنامه های تحت دات نت. در زير مزيت ها و توانايی های اين شئ بررسی شده است تا بتوان ديدی صحيح تر نسبت به آن پيدا کرد.

مزيت های شئ IrMail

امکان ارسال نامه با قابليت Authentication
همانطور که ذکر شد، شئ ذاتی NET. بدليل سادگی آن، قابليت Authentication (شناسائی) را به ما نمی دهد. اما برخی اوقات سرويس دهنده های SMTP ما را مجبور می کنند تا قبل از ارسال نامه، خود را معرفی (login) کرده و يا به اصطلاح Authenticate شويم. در IrMail اين مساله بخوبی پياده سازی شده است. به صورتی که با تنظيم دو خصيصه username و password عمليات Authentication به سادگی انجام می شود.

امکان ارسال نامه های فارسی بدون نگرانی از نحوه خوانده شدن
اين مورد نيز يکی از امکانات بالقوه اين شئ می باشد که در نوع خود تقريبا جديد و منحصر بفرد است. اين ويژگی که تحت عنوان UTF8AnyWhere ذکر می شود، باعث می شود نامه های شما در هر جايی که UTF8 را پشتيبانی می کند حتما به صورت فارسی ديده شود. از آنجا که امروزه تقريبا تمام سيستم عامل ها از استاندارد يونيکد پشتيبانی می کنند، عدم توانايی خواندن نامه های فارسی بسيار کم می شود. بطور واضح آنکه به همان اطمينانی که شما سايت خود را بصورت يونيکد طراحی می کنيد تا فارسی ديده شدن آن تضمين شود، همين تضمين نيز برای درست خوانده شدن نامه های شما بوجود می آيد. به بيان ساده تر هرجا سايت شما فارسی ديده شود، اين تضمين هست که نامه های شما نيز فارسی ديده شود. نکته ديگر اينکه نامه های شما در هر نوع Encodingای که قرار داده شده باشد، بازهم فارسی ديده می شود و لزومی نيست که حتما Encoding نامه بصورت UTF8 باشد. بنابر آنچه گفته شد، نامه های شما چه در Hotmail، چه در Yahoo و چه در هر سرويس دهنده ديگری حتما فارسی ديده می شود. استفاده از اين ويژگی بسيار ساده است و با True کردن property مربوطه، کليه عمليات لازم برای اين کار به صورت خودکار انجام می شود.

تضمين ارسال تمامی نامه ها حتی در صورت قطع بودن موقتی سرويس دهنده SMTP
مشکل ديگری که کما بيش سايت های مختلف با آن مواجه هستند، قطع شدن موقتی SMTP Server می باشد. مثال زير را در نظر بگيريد. در بعضی مواقع سرويس دهنده SMTP بنا به دلايل مختلفی برای مدتی (هرچند کوتاه) قطع می شود و از آنجا که اکثر ميزبانها برای يک خرابی جزيی خود را لازم به توضيح نمی بينند، بنابراين شما از اين وضعيت مطلع نخواهيد شد و درنتيجه قادر نخواهيد بود که اقدامی را در اين زمينه انجام دهيد. البته هميشه هم تقصير بر گردن ميزبانها نيست و گاهی خود سرور با مشکل مواجه می شود. شايد اين مشکل در نگاه اول جدی به نظر نرسد. اما اگر در همين زمان يک شرکت بزرگ قصد داشته باشد به شما پيشنهاد همکاری دهد و از طريق صفحه "تماس با ما" و از طريق فرم تهيه شده در آن، قصد ارسال نامه ای به شما را داشته باشد چه رخ خواهد داد؟ خوب عملا اين نامه هرگز ارسال نخواهد شد و شايد شما يک موقعيت استثنايی را به همين سادگی از دست بدهيد!

در طراحی شئ IrMail اين مشکل عملا از بين رفته است. چرا که در صورت عدم امکان ارسال نامه توسط سرويس دهنده SMTP در آن لحظه، نامه مذکور را ذخيره کرده و در تماس بعدی با سرويس دهنده SMTP، (در صورت فعال بودن آن) سعی در ارسال مجدد نامه های ارسال نشده خواهد کرد. بدين ترتيب حتی اگر SMTP Server برای مدت مديدی هم قطع باشد، ديگر شما نگران از دست دادن هيچ نامه ای نخواهيد بود. اين مورد برای تمام نامه هايی که از طريق اين شئ ارسال و يا دريافت می شوند صدق خواهد کرد. در طراحی اين فرآيند، نکات زير رعايت شده است:

۱- فايل حاوی نامه های ذخيره شده از نوع XML می باشد. بنابراين حتی اگر درآينده NET. بر روی سرور Linux و يا حتی هر سرور ديگری ارايه شد، با مشکل مواجه نمی شود. چراکه XML يک استاندارد است که بر فايل های ساده متنی متکی است.

۲- از آنجا که ظرف ذخيره سازی، يک فايل متنی ساده است، از مديريت و کنترل دسترسی های همزمان در آن خبری نيست. بدين معنی که اگر SMTP Server فعال نبود و در آن واحد دو کاربر قصد ارسال نامه را داشتند، به احتمال زياد منبع مورد نظر بهم می ريزد (Not thread-safe). در اينجا نيز مشکل برطرف شد و اين مديريت با توجه به امکاناتی که NET. در کنترل منابع همزمان فراهم کرده است ايجاد شده است ( برای اطلاعات بيشتر به مقاله Threadها در ASP.NET مراجعه کنيد). بدين ترتيب دسترسی های همزمان مشابه آنچه در DBMS ها رخ می دهد، امکان پذير است.

نمونه ای از نحوه استفاده از شئ IrMail
از آنجا که اين شئ در هر بار ايجاد نياز به تنظيمات خاصی دارد (مثلا Username ،Password، محل دخيره سازی نامه های ارسال نشده و...) که برای هر سايت منحصربفرد است، پيشنهاد می شود که به صورت زير عمل شود.

يک کلاس از کلاس IrMail.Mail را به ارث برده و تنظيمات خاص خود را در سازنده (Constructor) آن قرار دهيد. در هنگام نياز به ارسال نامه فقط کافی است يک نمونه از کلاس ارث بری شده را ايجاد کنيد (نمونه ای از اين ارث بری در زيربه زبان VB.NET نشان داده شده است).

Public Class MySmtpMail
Inherits IrMail.Mail

Public Sub New()

MyBase.New(HttpContext.Current.Server.MapPath("") )

مقدار پارامتر سازنده کلاس IrMail.Mail محل مکانی را نشان می دهد که می خواهيد نامه های ارسال نشده در آنجا ذخيره شود. در اين مثال محل دخيره سازی را برابر با دايرکتوری ريشه سايت قرار داديم . شما می توانيد جهت امنيت بيشتر، اين محل را تغيير و به مکان ديگری منتقل کنيد (بطور مثال دايرکتوری محل ذخيره DBها که معمولا fpdb می باشد).

Me.SMTPserver = "YourSMTPServer"
Me.PickUpDirectory = "c:\inetpub\mailroot\pickup"

خصيصه فوق (PickUpDirectory) مورد نياز SMTP Server می باشد.

Me.UserName = "YourUsername"
Me.Password = "YourPassword"

موارد فوق از آن جهت نياز است که بتوانيد نامه های ارسالی خود را از طريق سرويس دهنده هايی که نياز به Authentication دارند نيز ارسال نمائيد. در صورتيکه سرويس دهنده شما نيازی به Authentication ندارد، نيازی به تعيين نام کاربری و کلمه رمز نداريد.

Me.UTF8AnyWhere = True

اين خصيصه باعث می شود نامه شما در همه جا فارسی ديده شود. در صورتی که نامه شما انگليسی است، می توانيد اين خصيصه را false قرار دهيد. مقدار پيش فرض آن نيز false است.

Me.LoadSharedObject4WebApplication(HttpContext.Current)

استفاده از دستور فوق هميشه اجباری است و بايد به همين صورت باشد. در صورتی که دستور فوق ذکر نشود، مکن است شئ شما با مشکل مواجه گردد.

End Sub
End Class

حال هرجا در سايت خود قصد داشتيد که نامه ای را ارسال کنيد، کافيست يک نمونه از کلاس فوق را ساخته و ساير خصوصيات آنرا تنظيم نماييد. به عنوان مثال:

Dim ObjMailer As New MySmtpMail ()
ObjMailer.From = "EveryOne@Server.Com"
ObjMailer.To= "EveryOne@AnotherServer.Com"
ObjMailer.Subject = "New Email Object"
ObjMailer.Body= "The body of your mail in each language"
ObjMailer.Send()

و بدين ترتيب نسبت به ارسال نامه خود اقدام کنيد. نمونه برنامه کامل را می توانيد از آدرس http://www27.brinkster.com/mahmoud690/irmail/sample.htm دريافت کنيد.

توجه: متد IrMailMail.Send دارای يک پارامتر اختياری است که به صورت پيش فرض true می باشد. اگر آنرا به false تنظيم کنيد بدين معنی است که اگر smtp server فعال نبود، لازم نيست آنرا ذخيره کند (غير فعال کردن ويژگی آخر). اين مورد در مواردی کاربرد دارد که ارسال شدن يا نشدن نامه برای شما آنقدر اهميت نداشته باشد.

نکته آخر: ... مجانی به همراه کد! (Free And OpenSource)

اين شئ برای همه به صورت مجانی قابل دريافت و استفاده است. در ضمن کدهای اين کلاس به صورت مجانی نيز قابل دريافت است. اين بدين معنی است که شما می توانيد کدها را مشاهده کرده و آنها را مطابق ميل خودتان دستکاری و استفاده نماييد (OpenSource). اين شئ بر روی ليست اشيا مايکروسافت نيز ثبت شده است و اميدوار هستيم اين شئ به عنوان اولين شئ ايرانی که در اين ليست ثبت شده باعث گردد دوستان ديگر نيز نسبت به ثبت اشيا خود در آن اقدام کنند، چراکه اين ليست به عنوان يک کاتالوگ معتبر اشيا NET. در نزد برنامه نويسان مطرح است و مسلما وجود اشيا مختلف از برنامه نويسان ايرانی و با نام ايران، اعتبار سايت و برنامه نويسان ايرانی را در نزد ديگران افزايش خواهد داد.

نهايت آنکه اهداف من از Opensource قرار دادن کلاس فوق به صورت زير است:

- مسلما اين شئ نه آنقدر کامل و بی عيب است و نه دانش من در اين زمينه به اندازه کافی کامل و تخصصی است که بخواهم آنرا بصورت تجاری ارايه دهم. ضمن آنکه امکانات آنرا نيز ندارم.
- با opensource قرار دادن آن، امکان کمک و ياری گرفتن از ساير دوستان را نيز فراهم کرده ام. ضمن آنکه اينگونه برنامه ها امتحان خود را پس می دهند.
- و نهايت آنکه باز کردن کدهای NET. از روی فايل های Exe يا Dll آنها بسيار ساده است!

بطور خلاصه آنکه اين شئ متعلق به خود شماست و از همينجا از تمامی دوستانی که در اين زمينه فعاليت دارند درخواست دارم که با استفاده از اين شئ و يافتن نقاط ضعف و کاستی ها و کمبودهای آن من را در جهت تکميل آن ياری دهند. در مقابل هم تنها کاری که از دست من در برابر لطف اين دوستان برمی آيد اين است که نام آنها را به عنوان يکی از برنامه نويسان و يا debuggerهای آن ذکر کنم.

آدرس سايت انگليسی:
http://www27.brinkster.com/mahmoud690/irmail
آدرس مستقيم Download شئ کامپايل شده:
http://www27.brinkster.com/mahmoud690/irmail/downloadAssembly.htm.htm
آدرس مستقيم Download کدهای برنامه:
http://www27.brinkster.com/mahmoud690/irmail/Download-source.htm
آدرس اين شئ در کنترل گالری سايت رسمی ASP.NET:
http://www.asp.net/ControlGallery/ControlDetail.aspx?Control=1918&tabindex=2

همه مقالات کليات ASP.NET را ببينيد.
جستجو: بگرد!
جستجوی پيشرفته
نام کاربری |
کلمه عبور |


IranASP.NET - افزودن یک ستون انتخاب به DataGrid

افزودن یک ستون انتخاب به DataGrid

سلمان هوشمند | اين مقاله ۴۵۱۲ بار تاکنون ديده شده است.
۱۳۸۲/۱۲/۱۹ | برای وبلاگ برای وبلاگ دريافت کد
حتما ديده‎ايد که مثلا صندوق های پستی Hotmail و Yahoo به کاربران اجازه میدهند تا در لیست ایمیل های خود یک یا چند ایمیل را انتخاب کرده و عمل واحدی را روی آن انجام دهند. انتخاب هر ايميل با تيک زدن يک checkbox کنار آن انجام می شود. شاید بخواهید چنین کاری را در ASP.NET هم انجام دهيد. ولی DataGrid موجود در ASP.NET این امکان را بطور خودکار به شما نمی دهد و عمده‌ی کار را خود شما باید انجام دهید. در این مقاله مراحل لازم برای افزودن ستون انتخاب به DataGrid توضیح داده شده است.

صورت مساله
فرض کنید Datagrid ای داریم که اطلاعات دانشجویان یک کلاس را در خود دارد (دقیقاً نام، نام خانوادگی و ID آنها). میخواهیم یک ستون انتخاب به Datagrid خود اضافه کنیم، در داخل این ستون یک checkbox قرار دارد و با انتخاب آن، سطر انتخاب میشود.

راه حل
برای ایجاد لیست دانشجویان تابع زیر را به کد خود اضافه کنید. این تابع یک DataTable ساخته که دو ستون firstname و lastname از نوع String و یک ستون ID از نوع Integer دارد که شماره شناسایی منحصر بفرد دانشجوست. DataTable حاوی اطلاعات پنج دانشجو می باشد.

Private Function generateDataSource() As DataTable
Dim dt As New DataTable
dt.Columns.Add(New DataColumn("FirstName", Type.GetType("System.String")))
dt.Columns.Add(New DataColumn("LastName", Type.GetType("System.String")))
dt.Columns.Add(New DataColumn("ID", Type.GetType("System.Int32")))
Dim dr As DataRow
dr = dt.NewRow
dr.Item(0) = "Salman"
dr.Item(1) = "Zoroofi"
dr.Item(2) = "1"
dt.Rows.Add(dr)
dr = dt.NewRow
dr.Item(0) = "Ali"
dr.Item(1) = "Mohammadi"
dr.Item(2) = "2"
dt.Rows.Add(dr)
dr = dt.NewRow
dr.Item(0) = "Reza"
dr.Item(1) = "Maghsoodi"
dr.Item(2) = "3"
dt.Rows.Add(dr)
dr = dt.NewRow
dr.Item(0) = "Maryam"
dr.Item(1) = "Moosavi"
dr.Item(2) = "4"
dt.Rows.Add(dr)
dr = dt.NewRow
dr.Item(0) = "Ehsan"
dr.Item(1) = "Mojtahedi"
dr.Item(2) = "5"
dt.Rows.Add(dr)
Return dt
End function

برای ارجاع به اینِ DataTable یک متغیر عمومی به نام dt از نوع DataTable تعریف کنید (یعنی آنرا داخل بدنه‌ی کلاس و خارج از بدنه‌ی هر متد تعریف کنید مثلاً درست قبل از Page_load).

Private dt As DataTable

متد Page_Load خود را به صورت زیر تغییر دهید. این متد به dt مقدار اولیه داده و بعضی از خصوصیات Datagrid را تنظيم میکند.

Private Sub Page_Load(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles MyBase.Load
DataGrid1.AllowPaging = True
DataGrid1.PageSize = 3
If Not IsPostBack Then
dt = generateDataSource()
viewstate.Add("dt", dt)
DataGrid1.DataSource = dt
DataGrid1.DataBind()
Else
dt = CType(viewstate("dt"), DataTable)
DataGrid1.DataSource = dt
End If
End Sub

افزودن یک ستون انتخاب به Datagrid

یک Datagrid روی فرم قرار دهید، روی آن کلیک راست کرده و Property Builder را انتخاب کنید. در قسمت Columns زیر عنوان Available Columns، گزینه‌ی Template Column را انتخاب کرده و روی دکمه‌ی < کلیک کنید تا این ستون به قسمت Selected Columns اضافه شود. در قسمت Header text نام آنرا به Select تغییر دهید. پنجره را OK کرده و به فرم برگردید. حال باید به این ستون یک checkbox اضافه کنیم. روی Datagrid کلیک راست کرده و Edit Template و Select - Column [0] را انتخاب کنید. در صفحه‌ی جدیدی که ظاهر میشود یک checkbox به داخل قسمت Item Template بیاندازید. برای برگشت به صفحه‌ی اصلی روی این قسمت کلیک راست کرده و End template editing را انتخاب کنید.

مدیریت لیست سطر های انتخاب شده

نکته‌ی مهم در مورد DataGrid اینجاست که DataGrid با هر بار فراخوانی متد DataBind، خود را مجدداً از روی Datasource میسازد . و چون ستون انتخاب ما جزئی از DataSource نیست پس تمام سطرهای انتخاب شده با فراخوانی متد Databind به حالت انتخاب نشده میروند(حالت پیش فرض). راه حل این مشکل این است که قبل از Databind، سطر هایی که انتخاب شده اند را در جایی ذخيره کرده و درست بعد از فراخوانی DataBind آنها را به داخل Datagrid مجددا بارگذاری کنیم.
در اینجا لازم نیست تمام اطلاعات سطرهای انتخاب شده را ذخيره کنیم بلکه کافیست مقدار ستون ID آنها را ذخيره کنیم. زیرا این ID منحصر بفرد بوده و بوسیله‌ی آن میتوان به بقیه اطلاعات فرد هم دسترسی پیدا کرد. این ID ها در یک arraylist به نام arrselected که به صورت عمومی تعریف میشود قرار میگیرند.

Public Shared arrselected As New ArrayList

دقت کنید که تعریف یک متغیر یه صورت shared باعث میشود که مقدار آن در رفت و برگشت های (postback) متوالی به سرور حفظ شود.

سپس باید برای دو رویداد DataBinding و PreRender شی Datagrid کد نوشت: اولی قبل از انجام DataBind (برای عمل ذخيره) و دومی بعد از DataBind (برای عمل load). رویداد PreRender دقیقاً قبل از تولید کد HTML مربوط به Datagrid روی میدهد. در رویداد ID ،DataBinding سطرهای انتخاب شده را به arrselected اضافه کرده (یا اگر قبلاً انتخاب شده بود و هم اکنون انتخاب نشده بود از arrselected حذف میکنیم).

Private Sub DataGrid1_DataBinding(ByVal sender As Object, ByVal e As System.EventArgs) Handles DataGrid1.DataBinding
For Each i As DataGridItem In DataGrid1.Items
'add
If CType(i.FindControl("checkbox1"), CheckBox).Checked AndAlso Not arrselected.Contains(i.Cells(3).Text) Then
arrselected.Add(i.Cells(3).Text)
End If
'remove
If Not CType(i.FindControl("checkbox1"), CheckBox).Checked Then
arrselected.Remove(i.Cells(3).Text)
End If
Next
End sub

و در رويداد ID ،prerender سطر های Datagrid را با IDهای موجود در arrayselected مقایسه کرده اگر این ID قبلاً انتخاب شده بود checkbox مربوط به آنرا تیک میزنیم.

Private Sub DataGrid1_PreRender(ByVal sender As Object, ByVal e As System.EventArgs) Handles DataGrid1.PreRender
For Each i As DataGridItem In DataGrid1.Items
If arrselected.Contains(i.Cells(3).Text) Then
CType(i.FindControl("checkbox1"), CheckBox).Checked = True
End If
Next
End Sub

خصوصیت مهم این روش در این است که حتی اگر Datagrid را sort کرده یا از صفحه‌ی جاری به صفحه‌ی دیگری رفته و دوباره به این صفحه برگردید تیک ها سر جای خود می مانند. برای افزودن قابلیت تغییر صفحه، کد زیر را به code behind اضافه کنید.

Private Sub DataGrid1_PageIndexChanged(ByVal source As Object, ByVal e As System.Web.UI.WebControls.DataGridPageChangedEventArgs) Handles DataGrid1.PageIndexChanged
DataGrid1.CurrentPageIndex = e.NewPageIndex
DataGrid1.DataBind()
End Sub

برای دیدن برنامه در حال اجرا اینجا را کلیک کنید

خلاصه
در این مقاله با نحوه‌ی اضافه کردن یک ستون انتخاب به Datagrid آشنا شدید. ابتدا یک ستون template column که یک checkbox در خود دارد به Datagrid اضافه کردید. با دو رویداد DataBinding و PreRender آشنا شده در اولی لیست سطرهای انتخاب شده را به ‌روز میکنید و در دومی وضعیت انتخاب سطرهای Datagrid را از روی این لیست تعیین میکنیم.

همه مقالات فرم های وب را ببينيد.
جستجو: بگرد!
جستجوی پيشرفته
نام کاربری |
کلمه عبور |


IranASP.NET - تاييد و شناسايی کاربران بر اساس فرمهای وب در برنامه‎های ASP.NET

تاييد و شناسايی کاربران بر اساس فرمهای وب در برنامه‎های ASP.NET

احسان وليزاده | اين مقاله ۵۱۲۷ بار تاکنون ديده شده است.
۱۳۸۳/۱/۱۶ | برای وبلاگ برای وبلاگ دريافت کد
برنامه‎های وب ASP.NET می توانند از سه روش مختلف برای شناسائی و تاييد کاربران وب سايت استفاده کنند. اين روش ها عبارتند از: Windows Authentication ، Forms-Based Authentication و Passport Authentication. آیا می دانيد شناسايی کاربران در سايت Iranasp.net به کدام روش انجام می گيرد؟ يا اگر وارد سايت Iranasp.net شده ولی هنوز شناسايی نشده باشيد و بخواهيد به يک صفحه امن وارد شويد چه اتفاقی می افتد؟ اين مقاله به اين نوع سوالات پاسخ می دهد و شما را قدم به قدم با چگونگی شناسايی کاربران آشنا می کند.

برنامه های وب ASP.NET می توانند از سه روش مختلف برای شناسائی و تاييد کاربران وب سايت استفاده کنند. اين روش ها عبارتند از: Windows Authentication ،Forms-Based Authentication و Passport Authentication. آیا می دانيد شناسايی کاربران در سايت Iranasp.net به کدام روش انجام می گيرد؟ برای مثال اگر وارد سايت Iranasp.net شده ولی هنوز شناسايی نشده باشيد و درخواست يک صفحه امن مانند http://www.iranasp.net/Members/postnews.aspx که مخصوص کاربران است را بکنيد نمی توانيد به اين صفحه دسترسی داشته باشيد. در اين حالت شما به صفحه ای که حاوی فرم Login سايت است هدايت می شويد زيرا اين سايت کاربران خود را به روش Forms-Based Authentication شناسايی می کند. در اين مقاله مراحل لازم برای تاييد و شناسايی کاربران يک وب سايت بر اساس فرمهای وب، يعنی Forms-Based Authentication قدم به قدم مورد بررسی قرار می گيرد.

اين مقاله شامل بخشهای زير می باشد:

• ملزومات
• ايجاد یک برنامه ASP.NET با استفاده از Visual Studio.NET (زبان: Visual Basic.NET)
• پيکربندی تنظيمات امنيتی در فايل Web.config
• ايجاد يک جدول در پايگاه داده برای ذخيره جزئيات و مشخصات کاربران
• ايجاد يک فرم Logon.aspx که محل شناسايی کاربران می باشد
• انجام کدنويسی برای برخی از رويدادها که بتوان کاربران را اعتبارسنجی کرد
• ايجاد يک صفحه default.aspx
• موارد ديگر
• منابع

ملزومات

در ابتدا لازم است ملزومات زير را بر روی سيستم خود آماده کنيد:

• Microsoft Visual Studio .NET
• Microsoft SQL Server
• Microsoft Internet Information Server (IIS) version 5.0 or later

ايجاد یک برنامه ASP.NET با استفاده از Visual Studio.NET (زبان: Visual Basic.NET)

۱- Visual Studio .NET را باز کنيد.
۲- يک برنامه وب ASP.NET را با زبان Visual Basic.NET ايجاد نماييد.

پيکربندی تنظيمات امنيتی در فايل Web.config

اين قسمت نشان می دهد که چگونه قسمتهای <authentication> و <authorization> فايل Web.config را تنظيم کنيم تا برنامه ASP.NET ساخته شده در قسمت بالا برای تاييد کاربران بر مبنای فرمها پيکربندی شود. برای اين کار مراحل زير را انجام دهيد.

۱- فايل Web.config را از پنجره Project Explorer باز کنيد.
۲- مد authentication را برابر "Forms" قرار دهيد.
۳- تگ <Forms> را قرار دهيد و خصوصيات مناسب آنرا تکميل کنيد (برای ديدن ليست کامل اين خصوصيات می توانيد به مستندات QuickStart مراجعه کنيد). قسمت authentication در فايل Web.config بايد به شکل زير باشد. می توانيد همين کد را کپی کرده و از منوی Edit در Visual Studio.NET گزينه Paste as HTML را انتخاب کنيد.

<authentication mode="Forms">
<forms name=".ASPXFORMSDEMO" loginUrl="logon.aspx"
protection="All" path="/" timeout="30" />
</authentication>

۴- حال بايد با تغيير قسمت authorization به شکل زير مانع از ورود افراد ناشناس به صفحات شويد:

<authorization>
<deny users ="?" />
<allow users = "*" />
</authorization>

ايجاد يک جدول در پايگاه داده برای ذخيره جزئيات و مشخصات کاربران

اين مرحله چگونگی ايجاد يک جدول در پايگاه داده، برای ذخيره نام، کلمه عبور و نقش (وظيفه) کاربران را نشان می دهد.

۱- برنامه Notepad را باز کنيد.
۲- کد اسکريپت SQL زير را در آن کپی کنيد:

if exists (select * from sysobjects where id =
object_id(N'[dbo].[Users]') and OBJECTPROPERTY(id, N'IsUserTable') = 1)
drop table [dbo].[Users]
GO
CREATE TABLE [dbo].[Users] (
[uname] [varchar] (15) NOT NULL ,
[Pwd] [varchar] (25) NOT NULL ,
[userRole] [varchar] (25) NOT NULL ,
) ON [PRIMARY]
GO
ALTER TABLE [dbo].[Users] WITH NOCHECK ADD
CONSTRAINT [PK_Users] PRIMARY KEY NONCLUSTERED
(
[uname]
) ON [PRIMARY]
GO

INSERT INTO Users values('user1','user1','Manager')
INSERT INTO Users values('user2','user2','Admin')
INSERT INTO Users values('user3','user3','User')
GO

INSERT INTO Users values('user1','user1','Manager')
INSERT INTO Users values('user2','user2','Admin')
INSERT INTO Users values('user3','user3','User')
GO

۳- فايل را با نام Users.sql ذخيره کنيد.
۴- SQL Server را باز کنيد. فايل Users.sql را در Query Analyzer باز کنيد (برای دسترسی به محيط Query Analyzer می توانيد آنرا از منوی Tools در SQL Server اجرا کنيد). از ليست Databases پايگاه داده Pubs را انتخاب کنيد و اسکريپت (فايل Users.sql) را اجرا کنيد. اين کار جدولی به نام Users را در پايگاه داده Pubs ايجاد می کند و داده های نمونه ای را در آن برای استفاده در برنامه ASP.NET قرار می دهد. می توانيد به جای Pubs از پايگاه داده ديگری هم استفاده کنيد که در اين صورت، هنگام تعيين Connection String مربوط به آبجکت Connection بايد نام آن پايگاه داده را به جای Pubs قرار دهيد.

ايجاد يک فرم Logon.aspx که محل شناسايی کاربران می باشد

۱- يک فرم به نام Logon.aspx را به پروژه اضافه کنيد.
۲- در نمای HTML فرم Logon.aspx کد زير را بين دو تگ <Form> اضافه کنيد:

<h3>
<font face="Verdana">Logon Page</font>
</h3>
<table>
<tr>
<td>UserName:</td>
<td><input id="txtUserName" type="text" runat="server"></td>
<td><ASP:RequiredFieldValidator ControlToValidate="txtUserName"
Display="Static" ErrorMessage="*" runat="server"
ID="vUserName" /></td>
</tr>
<tr>
<td>Password:</td>
<td><input id="txtUserPass" type="password" runat="server"></td>
<td><ASP:RequiredFieldValidator ControlToValidate="txtUserPass"
Display="Static" ErrorMessage="*" runat="server"
ID="vUserPass" />
</td>
</tr>
<tr>
<td>Persistent Cookie:</td>
<td><ASP:CheckBox id="chkPersistCookie" runat="server" autopostback="false" /></td>
<td></td>
</tr>
</table>
<input type="submit" Value="Logon" runat="server" ID="cmdLogin"><p></p>
<asp:Label id="lblMsg" ForeColor="red" Font-Name="Verdana" Font-Size="10" runat="server" />

در اين فرم کاربرانی که می خواهند وارد سايت شوند شناسايی می شوند. اين فايل را ذخيره کنيد.

انجام کدنويسی برای برخی از رويدادها که بتوان کاربران را اعتبارسنجی کرد

اين قسمت حاوی کدی است که در فايل code-behind فرم Logon.aspx ) یعنی( Logon.aspx.vb قرار می گيرد.

۱- فايل logon.aspx.vb را باز کنيد.
۲- فضانام های مورد نياز را در فايل code-behind وارد کنيد:

Imports System.Data.SqlClient
Imports System.Web.Security

۳- يک تابع به نام ValidateUser ايجاد کنيد که مشخصات کاربران را برای اعتبارسنجی در پايگاه داده جستجو می کند. برای اين کار می توانيد از کد زير استفاده کنيد. (Connection String موجود در اين کد بايد مطابق با پايگاه داده شما باشد پس در صورت لزوم بايد آنرا مطابق با سيستم خودتان تغيير دهيد. در اينجا نام کامپيوتر من DOTNET می باشد و SQL Server به صورت Local نصب شده است).

Function ValidateUser(uid As string, passwd As string) As Boolean
Dim cnn As SqlConnection
Dim cmd As SqlCommand
Dim dr As SqlDataReader
Dim retVal As Boolean = False
cnn = New SqlConnection("Integrated Security=SSPI;Persist Security Info=False;Initial Catalog=pubs;Workstation ID=DOTNET;")
cmd = New SqlCommand("Select * from users where uname = '" & uid & "'", cnn)
cnn.Open()
dr = cmd.ExecuteReader()
While (dr.Read())
If Strcomp(dr.Item("Pwd"), passwd, 1) = 0 Then
retVal = True
End If
End While
cnn.Close()
ValidateUser = retVal
End Function

۴- شما می توانيد از يکی از روشهای زير برای ايجاد کوکی شناسايی بر اساس فرمها استفاده کرده و در رويداد cmdLogin_ServerClick کاربر را به صفحه‎ی مناسب هدايت کنيد. يکی از دو قطعه کد زير را برای رويداد cmdLogin_ServerClick بنويسيد:

- متد RedirectFromLoginPage را برای ايجاد خودکار کوکی شناسايی فراخوانی کنيد و کاربر را به صفحه ی مناسب هدايت کنيد:

Private Sub cmdLogin_ServerClick(ByVal sender As Object, ByVal e As System.EventArgs) _
Handles cmdLogin.ServerClick
If ValidateUser(txtUserName.Value,txtUserPass.value) Then
FormsAuthentication.RedirectFromLoginPage(txtUserName.Value, _
chkPersistCookie.Checked)
Else
lblMsg.Text = "Unknown User! try again."
End If
End Sub

- برچسب شناسايی (authentication ticket) را بسازيد و آنرا رمزنگاری کنيد. يک کوکی بسازيد و آنرا به پاسخ درخواست انجام شده از صفحه اضافه کنيد و کاربر را هدايت کنيد. اين روش امکانات زيادی را در رابطه با نحوه ساخت کوکی به شما می دهد. مثلا می توانيد داده های دلخواه خود را به کوکی اضافه کنيد:

Private Sub cmdLogin_ServerClick(ByVal sender As Object, _
ByVal e As System.EventArgs) Handles cmdLogin.ServerClick
If Validateuser(txtUserName.Value,txtUserPass.Value) Then
Dim tkt As FormsAuthenticationTicket
Dim cookiestr As String
Dim ck As HttpCookie

tkt = New FormsAuthenticationTicket(1, txtUserName.Value, DateTime.Now(), _
dateTime.Now.AddMinutes(30), chkPersistCookie.Checked, "your custom data")
cookiestr = FormsAuthentication.Encrypt(tkt)
ck = new HttpCookie(FormsAuthentication.FormsCookieName(), cookiestr)
if (chkPersistCookie.Checked) then ck.Expires=tkt.Expiration
ck.Path = FormsAuthentication.FormsCookiePath()
Response.Cookies.Add(ck)

Dim strRedirect As String
strRedirect = Request("ReturnURL")
If strRedirect <> "" Then
Response.Redirect(strRedirect, True)
Else
strRedirect = "default.aspx"
Response.Redirect(strRedirect, True)
End If
Else
lblMsg.Text = "Unknown User! try again."
End If
End Sub

ايجاد يک صفحه default.aspx

در اين قسمت يک صفحه به نام default.aspx می سازيم. اين صفحه برای کاربرانی است که شناسايی شده اند و قرار است که به اين صفحه هدايت شوند. اگر کاربری بدون اين که شناسايی شده باشد اين صفحه را درخواست کند به صفحه logon.aspx هدايت می شود.

۱- يک فرم جديد به نام default.aspx به پروژه اضافه کرده و آنرا در نمای HTML باز کنيد. کد زير را در بين تگ های <Form> اضافه کنيد:

<input type="submit" Value="SignOut" runat="server" id="cmdSignOut">

اين دکمه برای خارج شدن (log out) از صفحه default.aspx استفاده می شود. با کليک بر روی اين دکمه کوکی ساخته شده از بين می رود. اين فرم را ذخيره کنيد.

۲- فضانام لازم را در فايل code-behind مربوط به فرم default.aspx وارد کنيد:

Imports System.Web.Security

۳- کد زير را برای رويداد cmdSignOut_ServerClick اضافه کنيد:

Private Sub cmdSignOut_ServerClick(ByVal sender As System.Object, ByVal e As System.EventArgs) _
Handles cmdSignOut.ServerClick
FormsAuthentication.SignOut()
Response.Redirect("logon.aspx", True)
End Sub

۴- اکنون می توانيد از اين برنامه استفاده کنيد. همه فايلها را ذخيره کرده و برنامه را اجرا کنيد.

تمام کد مربوط به برنامه همراه با اسکريپت لازم برای ایجاد جدول در پايگاه داده را می توانيد از طريق همين صفحه دانلود کنيد.

موارد ديگر

• ممکن است شما بخواهيد که کلمه های عبور کاربران را به صورت امن و رمزنگاری شده در پايگاه داده ذخيره کنيد. در اين صورت می توانيد از تابعی به نام HashPasswordForStoringInConfigFile که يکی از توابع سودمند کلاس FormsAuthentication می باشد استفاده کنيد. به کمک اين تابع می توانيد کلمه های عبور را قبل از ذخيره کردن در پايگاه داده رمزنگاری کنيد.

• ممکن است بخواهيد اطلاعات مربوط به SQL Connection را در فايل پيکربندی (Web.config) ذخيره کنيد تا راحتتر بتوانيد آنرا تغيير دهيد.

• ممکن است بخواهيد کدهايی را برای جلوگيری از ورود هکرهايی که قصد دارند از ترکيبات مختلف کلمه های عبور برای ورود به سايت استفاده کنند، در نظر بگيريد. برای مثال می توانيد منطقی را پياده سازی کنيد که فقط تعداد مشخصی اقدام ورود به سايت را قبول می کند و اگر کاربری در تعداد معينی از انجام عمل ورود نتواند وارد سايت شود، در پايگاه داده با علامت زدن نام اين کاربر، ديگر اين کاربر غير فعال شده و با وارد کردن مشخصات درست نيز نتواند وارد سايت شود مگر اين که با بازديد از صفحه ای ديگر از سايت یا با تماس با واحد پشتيبانی شما بتواند حساب خود را دوباره فعال کند!

• به دليل اين که کاربر با کوکی تاييد اعتبار شناسايی می شود، ممکن است از Secure Socket Layer يا SSL در برنامه استفاده کنيد تا کسی نتواند کوکی و ساير اطلاعات باارزشی که در حال انتقال هستند را بدست آورد.

• تاييد اعتبار بر مبنای فرمها نيازمند اين است که کاربران سايت کوکی ها را در مرورگر خود فعال کنند.

• پارامتر timeout در بخش پيکربندی <authentication> مدت زمانی که کوکی تاييد اعتبار دوباره ايجاد می شود را تايين می کند، شما می توانيد هر مقداری را که مناسب می دانيد به اين پارامتر اختصاص دهيد.

منابع

می توانيد در آدرسهای زير مطالب مفيدی را در مورد تاييد کاربران بر مبنای فرمها و بحث امنيت در ASP.NET مشاهده کنيد:

http://www.gotdotnet.com/QuickStart/aspplus/default.aspx?url=/quickstart/aspplus/doc/formsauth.aspx

http://msdn.microsoft.com/library/en-us/cpguidnf/html/cpconcookieauthenticationusinganxmlusersfile.asp

http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpguide/html/cpconaspnetwebapplicationsecurity.asp

http://msdn.microsoft.com/library/dotnet/cpref/frlrfsystemwebsecurity.htm

http://msdn.microsoft.com/library/en-us/cpguide/html/cpconaspnetconfiguration.asp

http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpguide/html/cpgrfaspnetconfigurationsections.asp

http://msdn.microsoft.com/library/en-us/dnbda/html/authaspdotnet.asp

همه مقالات کليات ASP.NET را ببينيد.
جستجو: بگرد!
جستجوی پيشرفته
نام کاربری |
کلمه عبور |


IranASP.NET - صفحه نوردی در ASP.NET

صفحه نوردی در ASP.NET

مديريت سايت | اين مقاله ۴۶۱۳ بار تاکنون ديده شده است.
۱۳۸۳/۱/۳۰ | برای وبلاگ برای وبلاگ دريافت کد
حتما تاکنون بعنوان يک برنامه نويس وب به مقوله گزارشگيری برخورد نموده ايد. مثلا از شما خواسته اند که ليست فلان اقلام داده ای مانند ليست کالا، ليست سفارشات و... را تهيه کنيد. در بسيار از موارد اگر تعداد اين اقلام زياد باشد معمولا يک ليست بلند بالا را بر روی صفحه مانيتور از شما قبول نمی کنند. از طرف ديگر خود شما هم بعنوان يک برنامه نويس حرفه‎ای که برای کيفيت کار خود ارزش قائل هستيد نبايد براحتی از کنار اين مساله بگذريد. در يک کلام منظور اين است که آن ليست بلند بالا را صفحه بندی کرده و صفحه به صفحه نشان دهيد.

فرض کنيد که به سايت گوگل رفته ايد و کلمه iranasp را جستجو کرده ايد. من اين کار را کردم و در زمان نوشتن اين مقاله دقيقا تعداد ۱۶۲۰ مورد يافت شد! مقدار زيادی نيست ولی اگر قرار بود که گوگل همه اين موارد را تنها در يک صفحه به من نشان دهد و نه ۱۶۲ صفحه (با فرض در هر صفحه ده مورد)، گوگل ديگر به اين همه ثروت و شهرت نمی رسيد!! شايد فکر کنيد من ديوانه شده ام و اصولا چه ربطی ميان جستجوی کلمه iranasp و ثروت و قدرت امپراطوری گوگل وجود دارد؟ بله هيچ ربطی ندارد ولی تصور کنيد که روزانه ميليونها کاربر برای دفعات متعدد به دنبال کلمه يا کلماتی در گوگل و يا ديگر موتورهای جستجو می گردند و تعداد نتايج آنها به اندازه تعداد نتايج ما ۱۶۲۰ مورد نيست بلکه حاصل نتايج جستجوها بسيار بيشتر از اينها است. مساله اين است که نشان دادن همه نتايج در يک صفحه در بيشتر مواقع نه امکان پذير است و نه به صرفه.

بعبارت ديگر تصور کنيد که گوگل می خواست صفحه ای حاوی بيش از يک ميليون نتيجه جستجو را به ما نشان دهد. آيا می دانيد حجم اين صفحه به بايت چقدر می شد؟ من که نمی دانم ولی هرچه باشد آنقدر هست که حوصله من و شما سر برود و ديگر منتظر نمايش صفحه نتايج نشويم و عطای آن را به لقايش ببخشيم و بر روی آن ضربدر کوچک بالای پنجره ويندوز کليک کرده و آن را ببنديم و اين همان تير خلاص به قلب گوگل و اصولا هر سايتی است. اين يعنی اينکه من و شمای نوعی آن تبليغات درون صفحه گوگل را نمی بينيم و ديگر بر روی آن لينک که ممکن بود کليک کنيم ديگر حتما کليک نمی کنيم و آن کالای تبليغ شده را که ممکن بود بخريم ديگر حتما نمی خريم و باقی قضايا و اين يعنی همان چيزی که در بالا در مورد ثروت و شهرت گوگل گفتم و شما حرف من را جدی نگرفتيد! گوگل تنها يک مثال آشنا بود. اين مساله را به همه سايتهای وب و احتمالا محصولات نرم افزاری تعميم دهيد، خواهيد ديد همين "صفحه نورد" کوچک و ساده ما چه نقش مهمی دارد! اميدوارم که مطلب را گرفته باشيد!

صفحه نورد

عبارت صفحه نوردی را خودم از روی عبارت Page Navigation ساختم. بيشترين معانی Navigation حول و حوش دريانوردی دور می زند و من هم معادل صفحه نوردی را برای آن انتخاب کردم. شما اگر پيشنهاد بهتری داريد حتما با من تماس بگيريد. و اما صفحه نورد، حتما در پائين صفحات گوگل بعد از جستجوی کلمه ای که نتايج زيادی بهمراه داشته است يک تصوير گوگل با تعداد O های زياد و نيز در زير آن تعدادی شماره را ديده ايد. اگر نديده ايد(!) به تصوير زير نگاه کنيد.

صفحه نورد گوگل
شماره ها در اصل شماره صفحات نتيجه جستجو هستند و برای اينکه ليست اين شماره ها خيلی طولانی نشده و از صفحه بيرون نزند، در هر لحظه تنها تعداد معينی مثلا ده تا يا بيست تا از آنها آورده شده است. شما با کليک بر روی شماره ۹ به نهمين صفحه نتيجه می رويد و در هر صفحه ای که باشيد، با کليک بر روی کلمه Next يا Prev به ترتيِب به صفحه بعد يا قبل از آن می رويد.

حالا ما می خواهيم در اين مقاله يک صفحه نورد آن هم از نوع فارسی آن را بسازيم. فارسی بودن يعنی اينکه شماره صفحات و نيز عبارت Next و Prev همگی به خط زيبای فارسی باشند. نمونه عملی و کاربردی همين صفحه نورد را در همين سايت IranASP.NET در پائين صفحات خبرها، نتايج جستجو و يا ليست مقالات می بينيد.

چرا صفحه نورد؟

شايد برای شما اين سوال پيش بيايد که وقتی ما از ASP.NET استفاده می کنيم و از کنترل DataGrid آن برای گزارشگيری استفاده می کنيم که خودش امکان صفحه نوردی را به ما می دهد ديگر چه نيازی به اين صفحه نورد شماست؟ جواب اين است:

الف) DataGrid کنترل سنگين و حجيمی است و برای صفحاتی که سرعت دريافت در آنها حرف اول را می زند چندان مناسب نيست.

ب) برای استفاده از قابليت صفحه نوردی DataGrid شما مجبوريد در هر رفت و برگشت صفحه هر بار کليه رکوردهای نتيجه خود را مثلا هر ده هزارتا را هر بار به خورد DataGrid بدهيد تا او فقط مثلا ده تا را انتخاب و بر روی صفحه نشان دهد و بقيه را دور می ريزد. برای اينکار شما يا هر بار بايد به سراغ پايگاه داده خود رفته و تقاضای خود را برای دريافت ده هزار رکورد مورد نظر بدهيد و اين يعنی مصرف بالای منابع، کندی دسترسی به اطلاعات و طولانی شدن زمان نمايش صفحه و در اکثر مواقع از کار افتادن برنامه يا سايت شما در حالاتی که حجم داده خيلی بالا بوده و افراد زيادی به سايت شما آمده اند. اگر هم خوش شانس باشيد بگونه‎ای که همه کاربران سايت شما قرار است تنها به يک سری رکورد مشخص همواره نياز داشته باشند و شما بخواهيد آن تعداد را در حافظه سرورتان اصطلاحا Cache کنيد، بازهم ممکن است حافظه زيادی مصرف کنيد و دچار مشکلات ديگری شويد.

يکی از بهترين و کارآ ترين کنترلهای ASP.NET برای نمايش اطلاعات هم جنس، کنترل Repeater می باشد. اين کنترل ضمن سبکی و نياز کمتر به پردازش سمت سرور، دست برنامه نويس را برای هر نوع طراحی صفحه در نمايش اطلاعات باز می گذارد. تنها مشکل اين است که خودتان بايد مساله صفحه نوردی آن را حل کنيد. چيزی که اين مقاله به دنبال است. لازم بذکر است که اين صفحه نورد مورد نظر تنها برای استفاده در کنار Repeater طراحی نشده است و می توان آن را در کنار ساير تکرار کننده ها مانند DataGrid و DataList نيز استفاده نمود. بعبارت ديگر اين صفحه نورد هيچگونه وابستگی به هيچ نوع کنترلی در ASP.NET ندارد و می توان در هرکجا از آن استفاه کرد.

و اما اصل مطلب...

خوب تا اينجا هرچه گفتيم مقدمه چينی و حرف بود و احتمالا حوصله شما هم سر رفته است و بايد زودتر برويم سراغ اصل مطلب يعنی کد، والا آن ضربدر کوچک بالای پنجره، ما را هم تهديد می کند!

اين صفحه نورد بصورت يک کنترل کاربری يا يک User Control در نظر گرفته شده است تا بتوان براحتی در جاهای مختلف يک وبسايت از آن استفاده کرد. کد HTML اين کنترل به صورت زير است:

<%@ Control Language="c#" AutoEventWireup="false" Codebehind="PageNavigation.ascx.cs" Inherits="YourNamespace.PageNavigation" TargetSchema="http://schemas.microsoft.com/intellisense/ie5" %>
<P>
<TABLE cellSpacing="1" cellPadding="3" width="100%" border="0">
<TR>
<TD align="middle" dir="rtl">
<asp:Label id="lblNav" runat="server"></asp:Label>
</TD>
</TR>
</TABLE>
</P>

همانگونه که می بينيد اصل کد بالا عبارت است از تعريف يک کنترل از نوع Label و ساير متعلقات بنا به سليقه شما قابل تغيير است. بخش اصلی اين کنترل در قسمت کدبرنامه يا codebehind آن است. جهت اختصار همه کدبرنامه آن را اينجا نمی آورم و می توانيد کد کامل آن را از بالای همين مقاله دريافت کنيد. تنها به معرفی چند متد و متغير مهم آن می پردازيم.

• CurrentPage: متغيرنشان دهنده شماره صفحه فعلی. اين متغير توسط برنامه استفاده کننده جهت انتقال به روال ذخيره شده‎ی پايگاه داده، بکار می رود.

• PageSize: متغير نشان دهنده تعداد رکورد در هر صفحه. اين متغير توسط برنامه استفاده کننده جهت انتقال به روال ذخيره شده‎ی پايگاه داده، بکار می رود.

• TotalRecords: متغير نشان دهنده تعداد کل رکوردهای يافته شده. اين متغير توسط روال ذخيره شده‎ی پايگاه داده مقدار دهی می گردد.

• InitNav: از اين متد جهت مقداردهی اوليه صفحه نورد پيش از ارسال متغيرهای فوق به روال ذخيره شده پايگاه داده استفاده می گردد.

• ShowNav: اين متد جهت نمايش صفحه نورد در آخرين مرحله، فراخوانی می شود.

• CssClass: از اين متغير جهت تعيين کلاس CSS اين کنترل استفاده می شود.

• InActiveCssClass: از اين متغير جهت تعيين کلاس CSS موارد غيرفعال اين کنترل استفاده می شود (مانند کلمه "قبلی" هنگامی که در صفحه اول هستيم).

نحوه استفاده

اين کنترل، همانند يک User Control معمولی بکار می رود. اگر در Visual Studio .NET هستيد، در پنجره Solution Explorer برروی آن کليک کرده و بصورت drag-and-drop آن را در صفحه مورد نظر قرار دهيد. همچنين می توانيد کد زير را بصورت دستی در صفحه مورد نظر تايپ کنيد:

<%@ Register TagPrefix="uc1" TagName="PageNavigation" Src="PageNavigation.ascx" %>
...
<uc1:PageNavigation id="pnPageNavigate" runat="server"></uc1:PageNavigation>

حال جهت تعيين مقادير PageSize و CssClass و يا InActiveCssClass کد فوق را بصورت زير تغيير دهيد:

<uc1:PageNavigation id="pnPageNavigate" PageSize="10" runat="server" CssClass="yourclassname" InActiveCssClass="anotherclassname"></uc1:PageNavigation>

البته متغيرهای فوق بترتيب دارای مقادير 10 و "" و "" می باشند و لزومی به مقداردهی آنها نيست. همچنين اين مقادير را می توانيد از درون کدبرنامه استفاده کننده هم مقداردهی کنيد.

حال لازم است تا شئ ای از نوع کلاس صفحه نورد يعنی PageNavigation در کدبرنامه استفاده کننده تعريف نمائيم تا بتوانيم به اين کنترل از درون کدبرنامه استفاده کننده دسترسی داشته باشيم. برای اين کار بصورت زير عمل می کنيم:

protected YourNamespace.PageNavigation pnPageNavigate;

حال با استفاده از اين متغير مرجعی، به متغيرهای اساسی کنترل صفحه نوردمان دسترسی داريم. در کد زير نحوه بکارگيری آن را می بينيم.

this.pnPageNavigate.InitNav ();
DataSet ds = GetPagedAllNews (this.pnPageNavigate.CurrentPage ,
this.pnPageNavigate.PageSize,
out this.pnPageNavigate.TotalRecords);
this.repNews.DataSource = ds;
this.repNews.DataBind();
this.pnPageNavigate.ShowNav();

در کد فوق نحوه استفاده از متدهای InitNav و ShowNav را می بينيم. همچنين نحوه ارسال متغيرهای CurrentPage و PageSize و TotalRecords مشخص شده است. تا اينجا، کار ما با کنترل صفحه نورد تمام شده است. مساله مهم ديگر نحوه بازيابی اطلاعات از پايگاه داده و استفاده از مقادير متغيرهای فوق در قالب متد کمکی GetPagedAllNews است. اين متد را بصورت زير نوشته ايم:

private DataSet GetPagedAllNews (int CurrentPage, int PageSize, out int TotalRecords)
{
DataSet ds = new DataSet ();

// Create Instance of Connection and Command Object
SqlConnection myConnection = new SqlConnection(ConnectionString);
SqlCommand myCommand = new SqlCommand("procGetPagedAllNews", myConnection);
// Mark the Command as a SPROC
myCommand.CommandType = CommandType.StoredProcedure;
myCommand.Parameters.Add ("@CurrentPage", CurrentPage);
myCommand.Parameters.Add ("@PageSize", PageSize);
myCommand.Parameters.Add (new SqlParameter ("@TotalRecords", SqlDbType.Int));
myCommand.Parameters ["@TotalRecords"].Direction = ParameterDirection.Output;

// Create a new SqlDataAdapter object for the News table
SqlDataAdapter da = new SqlDataAdapter(myCommand);
// Populate the ds with the data
da.Fill(ds);
TotalRecords = Convert.ToInt32 (myCommand.Parameters ["@TotalRecords"].Value);

return ds;
}

بخش مهم ديگر در اينجا همان کد روال ذخيره شده procGetPagedAllNews می باشد که وظيفه واکشی رکوردهای مورد نظر را بصورت صفحه به صفحه دارد. از آنجا که شرح اين روال در اين مقال نمی گنجد تنها به آوردن کد آن اکتفا کرده ام. ابتدا يک جدول در SQL Server بنام News ساخته و دو عدد فيلد بصورت زير برای آن تعريف کنيد:

NewsID int
NewsTitle nvarchar (256)

سپس يک روال ذخيره شده بصورت زير در پايگاه داده تان بسازيد:

CREATE PROCEDURE dbo.procGetPagedAllNews
(
@CurrentPage int,
@PageSize int,
@TotalRecords int output
)
AS

SET NOCOUNT ON

--Create a temp table to hold the current page of data
--Add an ID column to count the records
CREATE TABLE #TempTable
(
ID int IDENTITY PRIMARY KEY,
NewsID int,
NewsTitle nvarchar (256),
)
--Fill the temp table with the News data
INSERT INTO #TempTable
(
NewsID,
NewsTitle,
)
SELECT NewsID, NewsTitle
FROM News

--Create variable to identify the first and last record that should be selected
DECLARE @FirstRec int, @LastRec int
SELECT @FirstRec = (@CurrentPage - 1) * @PageSize
SELECT @LastRec = (@CurrentPage * @PageSize + 1)
--Select one page of data based on the record numbers above
SELECT *
FROM
#TempTable
WHERE
ID > @FirstRec
AND
ID < @LastRec
--Return the total number of records available as an output parameter
SELECT @TotalRecords = COUNT(*) FROM #TempTable

حال ساير تنظيمات مانند ConnectionString در کدبرنامه صفحه اصلی را مطابق پايگاه داده خود قرار دهيد و ساير تنظيمات را انجام داده و برنامه را کامپايل و اجرا کنيد.

همه مقالات کليات ASP.NET را ببينيد.
جستجو: بگرد!
جستجوی پيشرفته
نام کاربری |
کلمه عبور |


IranASP.NET - توليد صفحات استاتيک به کمک XML و ASP.NET (بخش اول)

توليد صفحات استاتيک به کمک XML و ASP.NET (بخش اول)

بهروز نوعی پور | اين مقاله ۵۰۳۵ بار تاکنون ديده شده است.
۱۳۸۳/۲/۱۷ | برای وبلاگ برای وبلاگ
شايد برای شما جالب باشد که بدانيد سايت هايی بزرگی چون CNN يا news.com چگونه صفحات خود را توليد می کنند و اينکه چرا پسوند صفحات آنها مثلا بجای asp يا aspx يا php وغيره، html است؟ اين مقاله را بخوانيد تا با يکی از متداول‌ترين و مناسب‌ترين راه‌های توليد صفحات وب بصورت استاتيک برای سايت‌های با محتوای ديناميک مانند سايت های خبری يا مقاله‎ای آشنا شويد.

اشاره:

اين مقاله به تشريح يکی از متداول‌ترين و مناسب‌ترين راه‌های توليد صفحات وب برای سايت‌های با محتوای ديناميک از جمله سايت‌های ناشر خبر و مقاله به کمک XML می‌پردازد. روشی که در اين مقاله توضيح داده شده برای تمام فناوری‌های ايجاد صفحات ديناميک از جمله ASP.NET ،PHP ،JSP‌ و ColdFusion قابل اجراست اما در اين مقاله تنها به روش پياده سازی تکنيک مورد بحث با استفاده از ASP.NET اشاره شده است. برای اينکه بتوانيد از اين مقاله حداکثر استفاده را داشته باشيد، لازم است قبلا با مبانی XML و XSL آشنايی نسبی داشته باشيد ولی برای آندسته از خوانندگان که اطلاعات خيلی کمی دراين باره دارند، توضيحات مقدماتی آورده شده است.

صورت مساله

اگر يک طراح و برنامه‌نويس صفحات وب باشيد، حتما تاکنون متوجه شده‌ايد که يکی از روش‌های متداول برای نمايش محتوای اطلاعاتی در سايت‌های خبری اينست که به ازای هر خبر يا مقاله‌ی قابل نمايش در صفحات سايت، يک رکورد متناظر در پايگاه داده‌های (پايگاه داده) سايت قرار دهيم و اطلاعات درون فيلدهای هر رکورد را به محض درخواست بازديدکننده، داخل يک صفحه Template از جنس ASP يا ASP.NET و غيره نمايش دهيم. اما اگر احيانا به ساختار سايت‌های خبری بزرگ مانند CNN و news.com توجه کرده باشيد، ممکن است از خود پرسيده باشيد <چطور تعداد صفحات وب ديناميک اين سايت بسيار اندک يا در حد صفر است؟> چرا بعضی از سايت خبری بزرگ برای نمايش اخبار و مقالات خود از صفحات html به جای asp و aspx و php و jsp استفاده می‌کنند؟ چه رازی بر اين شيوه حاکم است و اصولا اين روش چه مزيتی دارد؟

به زبان ديگر، سوال اساسی اينست که آيا برای نمايش محتوای ديناميک در يک سايت وب، حتما مجبور به استفاده از صفحات ديناميک مانند ASP.NET و PHP‌ و غيره هستيم؟ يا اينکه ترفند ديگری هم وجود دارد؟

بررسی موضوع

در واقع پاسخ مثبت است. بسته به اينکه منطق شما برای توليد صفحات خبر و مقاله چگونه باشد، تکنيک‌های متفاوتی برای اين منظور وجود دارد که تنها يکی از آنها بکارگيری صفحات ديناميک است. روشهای ديگری هم برای نمايش محتوای ديناميک در سايت وجود دارند که ما يکی از آنها را که بهتر به نظر می‌رسد، بررسی خواهيم کرد. اما شايد يادآوری اين نکته بد نباشد که ببينيم روش مرسومی که غالبا سايت‌های کوچک و متوسط خبری بکار می‌برند ( و مورد نظر اين مقاله هم نيست) چگونه عمل می‌کند.

در روش متداول که آسان ترين روش نيز هست، شما به ازای تمام مقالات و اخباری که فرمت مشابهی دارند، فقط و فقط يک صفحه نمايش دهنده خبر يا مقاله، آنهم از جنس ASP.NET يا ASP می‌سازيد و به کمک آن، محتوای خبر يا مقاله مورد نظر را نمايش می‌دهيد. شما در حقيقت از روش رندرکردن (Render) صفحه در زمان نمايش استفاده می‌کنيد.

مهمترين کاری که بايد در اين تکنيک صورت گيرد، انتقال مقدار فيلد کليدی هر رکورد (معمولا فيلد id) به صفحه Template مذکور و خواندن اطلاعات همان رکورد از طريق يک فرمان SQL می‌باشد. به عنوان مثال با اجرای URL زير در يک سايت فرضی:

article.aspx?id=102632

مقدار id مساوی عدد 102632 به عنوان کليد رکورد به صفحه ASP.NET‌ انتقال يافته و در داخل صفحه، يک جا به کمک فرمانی مانند عبارت زير:

SELECT * FROM Articles WHERE ID=@id

اطلاعات فيلدهای مربوط به اين رکورد را می‌خوانيم و سپس در طول صفحه از طريق کدهايی مانند عبارت زير:

<#% DataBinder.Eval( Container, “DataItem.ArticleTitle” ) %>

داخل صفحه Template نمايش می‌دهيم.

چنانکه ملاحظه می‌کنيد، در اين روش هربار که کاربری قصد مشاهده خبر يا مقاله مورد نظر (با کد 102632) را داشته باشد، يکبار فرآيند فوق اجرا شده و صفحه ديناميک رندر می‌شود و سپس برای بازديدکننده نمايش داده ميشود.

در روش ديگری که مقصود اين مقاله است، ما مايل هستيم به ازای هر خبر يا مقاله، يک صفحه استاتيک متمايز داشته باشيم، طوری که کاربر برای مشاهده مطلب مورد نظر، به عنوان مثال با کليک کردن روی صفحه‌ای با نام 102632.htm بتواند آن را مشاهده کند. در اين روش بايد تکنيکی را پيدا کنيم که قبلا به ازای تمام رکوردهای خبر و مقاله درون بانک اطلاعاتی، يک صفحه وب توليد و روی server ذخيره کرده باشيم.

مزايای توليد صفحات استاتيک از روی رکوردهای پايگاه داده

قبل از هرچيز می‌خواهيم بدانيم اصولا فايده روش مذکور چيست و درحالی که خيلی ساده می‌توانيم از طريق ترفند article.aspx?id=102632 يک خبر يا مقاله خاص را به سادگی نمايش دهيم، چرا بايد به ازای هر خبر يک صفحه جداگانه وب توليد کنيم؟

۱- صفحات استاتيک سريعتر اجرا می‌شوند.
مهمترين دليل برای روی آوردن به اين روش آنست که به اين ترتيب سرعت نمايش صفحات سايت شما بالا می‌رود زيرا صفحات ديناميک مانند ASP.NET و PHP نياز به رندر شدن دارند درحالی که صفحات HTML‌ برای نمايش روی مرورگر کاملا آماده هستند. گذشته از اينها اگر يک سايت خبری پربيننده باشد، تعدد پردازش‌های ديناميک، فشار زيادی را روی سرور ايجاد می‌کند که در مجموع راندمان آن را پايين می‌آورد. حتی اگر سايت شما بيننده اندکی داشته باشد، در صورتی که از روش Shared Hosting استفاده کنيد، توانايی سرور برای همان تعداد اندک بازديدکننده چندان بالا نخواهد بود و شما در همان ميزان اندک نيز شاهد کاهش راندمان سايت متناظر با افزايش تعداد بازديدکنندگان خواهيد بود.

۲- Load‌ روی پايگاه داده کم می‌شود.
حسن بزرگ ديگری که از بکارگيری روش توصيه شده در اين مقاله حاصل می‌شود آنست که فشار روی پايگاه داده کم می‌شود. به عنوان يک توصيه کلی و يک اصل تجربه شده همواره به خاطر داشته باشيد که هرچه استفاده از پايگاه داده ها در يک سايت کمتر باشد بهتر است! اين هنر نيست که شما برای تکميل هر فرآيند کوچکی در سايت خود از پايگاه داده‌ استفاده کنيد زيرا افزايش ميزان استفاده از بانک اطلاعاتی موجب کند شدن سرعت نمايش صفحات از يک سو و نيز بالا رفتن ميزان منابع سيستمی مورد نياز برای پردازشهای ديناميک (resources) از سوی ديگر می‌شود. بنابراين همواره در جستجوی روش هايی باشيد که از پايگاه داده‌کمتر استفاده شود. استفاده موجز و مختصر و موثر از پايگاه داده يک روش صد در صد توصيه شده از سوی برنامه نويسان باتجربه است.

۳- وابستگی سايت شما به پايگاه داده کم می‌شود.
به طور کلی وقتی تعداد صفحات ديناميک يک سايت کمتر می‌شود، وابستگی آن به پايگاه داده‌ نيز کمتر می‌شود و اين به معنی کاهش منابع اشکال زا در هنگام وقوع خطاست. به عنوان مثال سايتی که شديدا به پايگاه داده ها وابسته است در صورتی که برای چند دقيقه پايگاه داده دچار مشکل يا down شود، ممکن است ده‌ها بازديدکننده را با خطا يا exception مربوط به در دسترس نبودن بانک اطلاعاتی مواجه کند. سايتی که از صفحات استاتيک بيشتر استفاده می‌کند کمتر در اين مواقع دچار اشکال و نارسايی می‌شود.

۴- جستجوی صفحه برای ماشين‌های جستجو آسان می‌شود.
دقت کنيد که برخی از موتورهای جستجو، چه آنهايی که روی کل اينترنت کار می‌کنند و چه آنهايی که روی يک سايت مشخص عمل می‌کنند، با برخی پارامترهای انتقال داده شده به يک صفحه ديناميک مشکل دارند. بهترين و سريع‌ترين روش ممکن برای ايندکس شدن صفحات وب يک سايت در يک موتور جستجو اينست که آن صفحه اساسا به صورت استاتيک باشد.

۵- استناد به URL‌ يک خبر يا مقاله خاص برای مردم آسانتر می‌شود.
فراموش نکنيد که وقتی آدرس يک خبريامقالهدرسايتشمابهصورتarticle.aspx?id=102632&cat=214&sessionid=423442
و مشابه اينها (يا در اغلب اوقات حتی پيچيده‌تر) است، به خاطر سپاری آدرس و يا درج آن در کتاب‌های و مجلات و روزنامه‌ها سخت‌تر می‌شود. درحالی که آدرس يک صفحه به صورت 102632.htm خيلی راحت‌تر است و احتمال اينکه موقع نوشتن يا تايپ يا حتی به خاطر سپردن آدرس، اشتباهی صورت بگيرد کمتر است.

۶- آرشيو کردن اخبار و مقالات بهينه‌تر می‌شود.
يادتان نرود که اگر قرار باشد سايت شما برای مدت چند سال فعاليت کند آنوقت بايد حجم عظيمی از اطلاعات را به صورت ديناميک داخل پايگاه داده‌ نگهداری کنيد. اينکار هم هزينه شما را بالا می‌برد ( بخصوص اگر از SQL Server‌ يا MySQL‌ يا ORACLE‌ و DBMS‌های ديگر استفاده کرده باشيد) و نگهداری‌اش سخت می‌شود. اگر مهمترين کاربرد بانک اطلاعاتی در سايت شما نگهداری محتوای اخبار و مقالات است، بهتر است فقط آخرين x رکورد را داخل پايگاه داده‌ دم دست نگه داريد و بقيه رکوردها را از بانک اطلاعاتی خارج، و به طريقی که صلاح می‌دانيد (مثلا ذخيره کردن به صورت صفحات استاتيک وب) آرشيو کنيد. به اين ترتيب رکوردهای قديمی شما خيلی ساده از طريق جابجا کردن صفحات وب، قابل انتقال خواهند بود و اگر زمانی تصميم بگيريد Host‌ خود را عوض کنيد، برای جابجا کردن داده‌های درون پايگاه داده‌ مکافات نخواهيد داشت!

۷- برای نمايش صفحات سايت به Host ارزان‌تری نياز خواهيد داشت.
به کمک روش توليد مکانيزه صفحات استاتيک می‌توانيد تمام يک سايت را با صفحات معمولی HTML بسازيد، بدون اينکه نيازمند استفاده از قابليت‌های يک web server خاص باشيد. مثلا اگر از يک ميزبان ارزان قيمت استفاده می‌کنيد که به شما اجازه استفاده از امکانات پيشرفته‌ای چون پايگاه داده را نمی‌دهد، می‌توانيد سايت خود را به طور کامل به صورت استاتيک بسازيد. به اين ترتيب که روی يک دستگاه خانگی سايت خود را شبيه‌سازی می‌کنيد و صفحات استاتيک را با روش توضيح داده شده در اين مقاله توليد می‌کنيد و سپس حاصل کار را در دوره‌های زمانی مشخص به ميزبان سايت اصلی خودتان upload می‌کنيد. البته اگر سايت خود را تمام استاتيک بسازيد، امکان پياده سازی قابليت‌هايی مانند جستجو (منظور خود صفحه جستجوگر است نه صفحاتی که مورد جستجو قرار می‌گيرند) را نخواهيد داشت.

قسمت دوم

همه مقالات کليات ASP.NET را ببينيد.
جستجو: بگرد!
جستجوی پيشرفته
نام کاربری |
کلمه عبور |


IranASP.NET - توليد صفحات استاتيک به کمک XML و ASP.NET (بخش دوم)

توليد صفحات استاتيک به کمک XML و ASP.NET (بخش دوم)

بهروز نوعی پور | اين مقاله ۴۹۱۴ بار تاکنون ديده شده است.
۱۳۸۳/۲/۲۳ | برای وبلاگ برای وبلاگ دريافت کد
شايد برای شما جالب باشد که بدانيد سايت هايی بزرگی چون CNN يا news.com چگونه صفحات خود را توليد می کنند و اينکه چرا پسوند صفحات آنها مثلا بجای asp يا aspx يا php وغيره، html است؟ اين مقاله را بخوانيد تا با يکی از متداول‌ترين و مناسب‌ترين راه‌های توليد صفحات وب بصورت استاتيک برای سايت‌های با محتوای ديناميک مانند سايت های خبری يا مقاله‎ای آشنا شويد.

قسمت اول

پس از بررسی مزايای توليد صفحات استاتيک به کمک XML و ASP.NET در قسمت اول اين مقاله، به چگونگی انجام اين کار می پردازيم.

توليد مکانيزه صفحات استاتيک به کمک XML

اکنون روش مورد نظر در اين مقاله را بررسی می‌کنيم. در اين روش به جای اينکه يک صفحه ديناميک از جنس ASP‌ يا ASP.NET بسازيم که محتوای هر خبر يا مقاله را نمايش بدهد، يک صفحه Template از جنس XSL می‌سازيم و محل قرارگرفتن داده‌های فيلدهای هر رکورد را داخل صفحه مشخص می‌کنيم. برای ساختن صفحات Template مذکور بايد ابتدا صفحات وب را به فرمت XHTML تبديل کنيم. سپس با قراردادن فيلدهای موردنظر،‌ صفحه XHTML را به XSL تبديل کنيم.

تبديل HTML‌ به XHTML

ساختن صفحات XHTML بسيار ساده است. کافی است صفحه معمولی خود را بسازيد و محل قرارگرفتن فيلدها را مشخص کنيد (مثلا از طريق تايپ کردن نام هر فيلد) و سپس به کمک يک مبدل HTML به XHTML صفحه وب خود را به فرمت سازگار با XHTML تبديل کنيد. برنامه‌ای مانند Dreamweaver به کمک يک فرمان ساده، اين کار را به راحتی آب خوردن انجام می‌دهد!

تفاوت يک HTML معمولی با يک HTML سازگار با فرمت XHTML چندان زياد نيست. درواقع کنترلی بايد روی صفحه انجام شود تا مطمئن شويم که tagهای صفحه در قياس با قواعد XML اصطلاحا well-form هستند. مثلا در فرمت XML هر tag که شروع می‌شود بايد حتما پايانی داشته باشد. مثل <table></table> اگر بعضی از tag ها قرار است که تنها باشند (مثل <br>) اين tag‌ ها بايد به صورت مثلا </br> اصلاح شوند. چند تغيير جزئی ديگر نيز بايد صورت گيرد تا صفحه کاملا با فرمت XHTML سازگار باشد. حتی اگر يک کاراکتر هم ناسازگار با قواعد XML‌ باشد، امکان استفاده از روش توضيح داده شده در اين مقاله وجود نخواهد داشت. ضمنا، کلاس و شئ XML‌ در دات‌نت بعضی از کاراکترها و ترکيب‌های کاراکتری را نيز نمی‌پذيرد. مثلا ;nbsp& که نمايانگر يک space‌ يا فاصله است، از ديد مفسر XML در دات نت مجاز نيست و به جايش بايد همان کاراکتر space‌ را تايپ کنيد. نگران نباشيد. محدوديت‌هايی که در اين زمينه وجود دارند بسيار اندک هستند و تقربيا صفحه خود را با حدود يکی دو درصد تغيير می‌توانيد به يک XHTML قابل استفاده برای کلاس XML‌ تبديل کنيد.

يادآوری مهم : ضروری است که صفحات فارسی خود را از جنس يونی‌کد و با کاراکترست utf-8 بسازيد. زيرا شئ xml در دات نت تنها در اين صورت می‌تواند اطلاعات فارسی را بدون مشکل پردازش کند.

تبديل XHTML‌ به XSL

اين قسمت از کار مهمترين قسمت ساختن Template مورد نظر است. برای اينکار بايد با استاندارد XSL و تکنيک‌ها و زبان آن آشنا شويد. XSL بحث مفصلی دارد و برای آموختن آن کتاب‌های متعددی چاپ شده است که لازم است حداقل يکی از آنها را به عنوان مرجع دم دست داشته باشيد. من برای سهولت کار، چند تکنيک ساده و پرکاربرد XSL‌ را که در اين مقاله نياز داريم، داخل فايل مثالی که ضميمه مقاله است، پياده کرده‌ام که می‌توانيد از آنها به عنوان الگو استفاده کنيد. XSL‌ به معنی eXtensible Stylesheet Language است. XSL در دنيای فناوری XML مشابه CSS در دنيای HTML است. اگر با CSS ها آشنايی داشته باشيد، درک کاری که XSL‌ انجام می‌دهد چندان برايتان مشکل نخواهد بود. همانطور که از CSS برای فرم دادن به صفحات وب استفاده می‌کنيم، از XSL‌ نيز برای فرم دادن به محتويات فايلهای XML‌ استفاده می‌کنيم.

تکنيک‌هايی که برای پردازش فايل‌های XSL و قراردادن داده‌های XML‌ استفاده می‌شود اصطلاحا XSLT نام دارد (به انتهای عبارت XSL کلمه Transformation‌ را بيفزاييد).

قلب فرآيندی که اتفاق می‌افتد به اين شرح است :

- داده‌های شما، يعنی اطلاعات رکوردهای خبر و مقاله بايد به فرمت XML درآيند.
- کد برنامه، فايل XSL شما را باز می‌کند و آن را برای يافتن tag های مخصوص نمايش فيلدهای اطلاعاتی جستجو می‌کند و به محض پيدا کردن محل فيلد، اطلاعات آن را جايگزين می‌کند.

به عنوان مثال عبارت <"xsl:value-of select="ArticleTitle> معادل گزينه‌ای است که چند پاراگراف بالاتر به عنوان روش نمايش فيلد ArticleTitle در صفحه ASP.NET شرح دادم. به عنوان نمونه ديگر، در زبان XSL با استفاده از syntax زير می‌توانيم يک حلقه بسازيم :

<xsl:for-each select="//Table">
...
</xsl:for-each>

که حلقه روی فيلدهای جدول Table‌ تکرار می‌شود.

کاری که ما در برنامه خود انجام می‌دهيم اينست که ابتدا رکوردهای بانک اطلاعاتی را با استفاده از شئ xml در دات نت به XML‌ تبديل می‌کنيم سپس با استفاده از کلاس xslt يک فايل XSL را بازميکنيم و داده ها را درون آن ميريزيم و حاصل را به صورت يک HTML معمولی ذخيره می‌کنيم. همين!

کد برنامه توليد مکانيزه صفحات وب با استفاده از ASP.NET

کاری که ما بايد انجام دهيد اينست که يک صفحه ASP.NET بسازيم که عمليات توليد صفحه استاتيک را به طور خودکار انجام دهد تا بتوانيم حاصل فرآيند را خيلی ساده روی سايت publish کنيم. البته می‌توانيم ASP.NET‌ را طوری بنويسيم که خودش در محل مشخص شده توسط ما صفحات HTML‌ توليد شده را save کند. در اينصورت بايد ميزبان شما قابليت استفاده از فناوری ASP.NET‌ را در اختيار شما قرار دهد وگرنه مجبوريد صفحات را روی دستگاه خودتان توليد کنيد و بعد حاصل کار را به صورت دستی يا به هر روش ديگر upload کنيد.

و حالا سورس کد :
( من از VB.NET استفاده کرده ام ولی خودتان می‌دانيد که چقدر تبديل آن به #C‌ آسان است)

۱- برای اجرای برنامه لازم است کلاسهای مورد نياز را import کنيم :

Imports System.Text
Imports System.Data
Imports System.Data.SqlClient
Imports System.IO
Imports System.IO.Path
Imports System.Xml
Imports System.Xml.Xsl

۲- من فرض را براين می‌گذارم که شما يک datagrid خودتان ساخته‌ايد و می توانيد در اين صفحه ASP.NET رکوردهای اخبار و مقالاتتان را مديريت کنيد. من در اين مقاله روش اينکار را توضيح نمی‌دهم چون روشش خيلی آسان و سرراست است و در همه سايت‌های مربوط به ASP.NET ميتوانيد يک دوجين مقاله درباره روش نمايش رکوردهای بانک اطلاعاتی توسط datagrid پيدا کنيد. شما بايد همچنين در اين datagrid امکان select کردن يک رکورد (جهت انجام پردازشها مورد نياز اين مقاله) را اضافه کنيد. اين کار نيز آسان است و من قصد آموزش آن در اينجا را ندارم.

۳- همه عمليات را يک تابع بسيار ساده و جادويی انجام می‌دهد :-)

Function GenerateOneHTML(ByVal RecordID As Integer) As Boolean

'single node-----------------------
Dim myData As DataSet = GetDataSet()
Dim doc As XmlDataDocument = New XmlDataDocument(myData)
Dim FileName As String
Dim ln As Integer
Dim node As XmlElement = doc.DocumentElement.SelectSingleNode("//Table[ID=" + RecordID.ToString + "]")

If Not node Is Nothing Then
Dim doc2 As XmlDocument = New XmlDocument
doc2.LoadXml(node.OuterXml)

'Generate HTML file name
FileName = RecordID.ToString
Dim HTMLsPath As String = Server.MapPath("\") + "Articles\" + Trim(doc2.SelectSingleNode("//Category").InnerText) + "\"

'Transform
Dim xslt As XslTransform = New XslTransform
xslt.Load(HTMLsPath + "temp.html")
Dim writer As XmlTextWriter = New XmlTextWriter(HTMLsPath + FileName + ".htm", System.Text.Encoding.UTF8)
'writer.Formatting = Formatting.Indented
'writer.Indentation = 2
xslt.Transform(doc2, Nothing, writer, Nothing)

writer.Close()
End If

Return True
End Function

از جزئيات اين تابع نترسيد. خيلی ساده در سه مرحله، يعنی در سه سوت (!) کار را تمام می‌کند.

من اين تابع را بعد از يک ماه تلاش مداوم به اين صورت خلاصه و مفيد نوشتم و خيالتان راحت باشد که صد در صد کار می‌کند. فقط توجه کنيد که نام فيلدهای استفاده شده در اين تابع با توجه به نامگذاری فيلدهای پايگاه داده خودم صورت گرفته است و شما بايد اين جزئيات تابع را مطابق نياز خود تغيير دهيد. مراحل سه گانه فوق به اين شرح هستند :

۱- خواندن xml از روی dataset
۲- توليد نام فايل خروجی
۳- تبديل (Tarnsform)

سومين مرحله که مهترين مرحله است، درواقع همان عمليات XSLT است. در اينجا بايد گفت دست طراحان معماری دات نت درد نکند که با چهار خط کد می‌توان يک فرآيند XSLT‌ را کامل کرد!

مرحله اول :
در اين مرحله از روی dataset يک xml‌ می‌سازيم :

'single node-----------------------
Dim myData As DataSet = GetDataSet()
Dim doc As XmlDataDocument = New XmlDataDocument(myData)
Dim FileName As String
Dim ln As Integer
Dim node As XmlElement = doc.DocumentElement.SelectSingleNode("//Table[ID=" + RecordID.ToString + "]")

توجه کنيد که من روش ساختن dataset‌ را توضيح نداده‌ام ولی شما خودتان می‌توانيد تابع GetDataSet را مطابق نيازتان بنويسيد. اين کار يکی از آسان‌ترين و ابتدايی ترين روشهای کار با رابط برنامه‌نويسی ADO.NET است (لابد می‌دانيد که دو روش عمده برای خواندن اطلاعات از بانک اطلاعاتی وجود دارد، يکی شئ DataReader و ديگری شئ DataSet) و من در اينجا برای اجتناب از طولانی شدن مقاله، از توضيح دادن آن صرف‌نظر کردم.

شئ جادوئی XmlDataDocument کارش تبديل dataset به XML است. خط آخر اين مرحله يک شئ XmlElement از روی همان رکوردی که می‌خواهيم اطلاعاتش را بخوانيم می‌سازد. دقت کنيد که چطوری نام جدول پايگاه داده و id رکورد را که به صورت input وارد تابع کرده‌ام، به اين شئ خورانده می‌شود.

مرحله دوم :
حالا بايد از روی خروجی xml شئ مذکور يعنی node.OuterXml يک شئ XmlDocument بسازيم و dataset را کنار بگذاريم (توجه کنيد که در سورس اصلی تابعی که نوشته‌ام، مرحله دوم و سوم را داخل يک شرط if قرار داده‌ام تا اگر رکورد مورد نظر پوچ بود اين دو مرحله اجرا نشوند):

Dim doc2 As XmlDocument = New XmlDocument
doc2.LoadXml(node.OuterXml)

'Generate HTML file name
FileName = RecordID.ToString
Dim HTMLsPath As String = Server.MapPath("\") + "Articles\" + Trim(doc2.SelectSingleNode("//Category").InnerText) + "\"

در واقع يک XmlDocument در کد برنامه دات نت، معرف يک xml است. و در تمام اين مقاله هرجا گفتم کلاس (يا شئ xml در دات نت) بيشتر مقصودم همين شئ بود. البته کل اشياء بکار رفته در اين مقاله از کلاس مادر System.xml و System.xml.xsl مشتق شده اند.

در ادامه اين مرحله من کمی با اطلاعات فيلد RecordID بازی کرده ام تا يک نام دلخواه و يک path مناسب برای دخيره کردن فايل HTML‌ نهايی جور کنم. همچنين اگر خواستيد روی داده‌های رکورد مورد نظر، پيش از قرارگرفتن در XSL تغييری انجام دهيد، مثلا تاريخ ميلادی را به شمسی تبديل کنيد، جايش همين مرحله است. با استفاده از syntax زير می‌توانيد به محتويات يک فيلد از اين رکورد دسترسی داشته باشيد (قابل خواندن و نوشتن):

doc2.SelectSingleNode("//FieldName").InnerText

مرحله سوم :
در اين مرحله عمليات جادويی تبديل صورت می‌گيرد!
خط اول يک XslTransform معرفی کرده ام. اين شئ يک تابع بدقلق اما فوق‌العاده نيرومند دارد که حدود ده تا تعريف overload دارد. يعنی می‌توان اين تابع را به چندين روش فراخوانی کرد. پيدا کردن حالت مناسب برای اين تابع خودش مکافاتی بود (!) ولی حالا نتيجه کار بسيار ساده از آب درآمده است. من فايل XSL که به روش توضيح داده شده ساختم را به اسم temp.html در همان مسيری (path) که می‌خواهم فايل خروجی را ذخيره کنم قرار دادم. ابتدا با استفاده از تابع load اين فايل را باز می‌کنم. سپس با استفاده از يک شئ جادويی ديگر به نام XmlTextWriter يک مجرای خروجی (يک stream) برای تابع Transform فراهم می‌کنم:

'Transform
Dim xslt As XslTransform = New XslTransform
xslt.Load(HTMLsPath + "temp.html")
Dim writer As XmlTextWriter = New XmlTextWriter(HTMLsPath + FileName + ".htm", System.Text.Encoding.UTF8)
'writer.Formatting = Formatting.Indented
'writer.Indentation = 2
xslt.Transform(doc2, Nothing, writer, Nothing)

writer.Close()

ذکر چند نکته در اينجا ضروری است:

۱- آدرسی که در مرحله دوم ساختم را به XmlTextWriter می‌دهم.
۲- فرمت يونی‌کد را نيز برای XmlTextWriter مشخص می‌کنم.
۳- اگر دلم خواست، از property فرمتينگ نيز استفاده می‌کنم:

writer.Formatting = Formatting.Indented
writer.Indentation = 2

اين property خيلی جالب و در عين حال دردسرساز است. کارش اينست که خروجی HTML شما را برای خواندن سورس آن فرم بدهد. اگر اينکار را نکنيد، XmlTextWriter تمام فايل HTML شما را در يک خط (!) می‌نويسد. هنگام نمايش HTML هيچ اتفاق يا مشکل خاصی پيش نمی‌آيد اما اگر برويد روی مرورگر گزينه view source را بزنيد متوجه می‌شود که خواندن اين فايل واقعا مکافات است!

Property فوق اين مشکل را برطرف می‌کند و خروجی HTML‌ را طوری توليد می‌کند که بشود سورس آن را (مثل آدم‌!) خواند. فقط اشکالش اينست که در برخی Layout‌ ها به دليل انداختن يک سری space اضافه، صفحه را از ريخت می‌اندازد. در مورد سايت من چنين مشکلی پيش آمد و من بيخيال فرمتينگ شدم. Property دوم که Indentation نام دارد ميزان تاثير گذاری فرمتينگ را مشخص می‌کند. عدد 2 نرمال است. اگر بيشتر بدهيد، nesting سورس HTML را بيشتر می‌کند، خودتان امتحان کنيد، متوجه خواهيد شد.

سرانجام فرمان آسمانی Transform انجام می‌شود. همه مقاله را به خاطر اين تابع پرتشريفات نوشتم. می‌خواستم از اول بگويم اين تابع چه تابع خوبی است، توی رودربايستی افتادم و اين مقاله را نوشتم!

فراموش نکنيد که مجرای XmlTextWriter را بايد پس از اتمام کار بست. حالا اگر به پوشه‌ای که می‌خواستيد فايلتان آنجا ذخيره شود مراجعه کنيد می‌بينيد که يک صفحه وب تر و تميز حاوی مقاله يا خبر شما آنجا نشسته و اسم دلخواه شما را نيز به خود گرفته است (در اينجا همان کد id).

بايد datagrid خودتان را طوری بسازيد که بشود از طريق يک checkbox کنار هر رکورد، آنهايی که مايليد صفحه خبر يا مقاله‌اش را بسازيد، مشخص کرد. سپس يکی يکی id اين رکوردها را به تابع مورد بحث می‌دهيد تا به ازای هرکدام از آنها يک صفحه بسازد. توجه کنيد که تکرار اجرای اين فرمان روی يک رکورد موجب overwrite شدن فايل قبلی می‌شود. يعنی می‌توانيد به سادگی فايل را update کنيد.

اگر خواستيد Layout سايت تان را تغيير دهيد، کافی است فايل XSL خود را يکبار دستکاری کنيد. اينکار خيلی ساده است. اگر XSL‌ را با پسوند htm يا html‌ ذخيره کنيد، برنامه‌ای مانند Dreamweaver آن را مانند يک صفحه وب معمولی باز می‌کند تا بتوانيد ويرايشش کنيد. بعد از تغيير XSL، يکبار ديگر فرمان Transformation را روی رکورهای مقالات و اخبار تکرارکنيد تا صفحات جديد را بدست آوريد.

نتيجه‌گيری :

اگر به صورت مساله اول مقاله برگرديم، حالا متوجه می‌شويم اين سايت‌های خبری بزرگ دنيا چطوری بدون استفاده از صفحات ديناميک، سايتهای فعالی دارند. در واقع کلکش خيلی آسان بود.

پی‌نوشت:

من خودم از اين تکنيک برای ساختن صفحات بخش مقالات سايتم استفاده کرده‌ام. البته در بخش وبلاگ سايتم از روش متداول و ديناميک بيشتر استفاده کردم ولی اگر به بخش مقالات مراجعه کنيد، متوجه می‌شويد که حتی يک صفحه ديناميک هم آنجا وجود ندارد.

همه مقالات کليات ASP.NET را ببينيد.
جستجو: بگرد!
جستجوی پيشرفته
نام کاربری |
کلمه عبور |


IranASP.NET - چگونگی ساخت Setup برای برنامه های NET. كه از Crystal Report استفاده می کنند

چگونگی ساخت Setup برای برنامه های NET. كه از Crystal Report استفاده می کنند

لطفعلی خوش نفس | اين مقاله ۴۳۰۶ بار تاکنون ديده شده است.
۱۳۸۳/۲/۳۱ | برای وبلاگ برای وبلاگ
برنامه نويسان حرفه ای معمولاً بعد از توليد برنامه‎ی خود، با استفاده از امکانات موجود در Visual Studio .NET برای آن يک Setup يا اصطلاحاً يک برنامه‎ی نصّاب می سازند. اما اگر برنامه شما جهت گزارشگيری از ابزار Crystal Report برای NET. استفاده کرده باشد، احتمالاً برنامه نصّاب شما به هنگام نصب به مشکلی برخورد خواهد کرد. اين مقاله را بخوانيد تا راه حل اين مشکل را بيابيد.

احتمالا تاكنون برنامه هايی با NET. نوشته و آن را روی سيستمی كه Visual Studio .NET. روی آن نصب نباشد امتحان كرده ايد. اين كار بدون هيچ مشكلی انجام می شود، كافی است برای برنامه خود Setup درست كنيد و بعد از نصب .NET Framework روی سيستم مورد نظر برنامه خود را نصب و اجرا كنيد.

اما اگر در برنامه خود گزارشهايی توسط Crystal Report نوشته باشيد حتی در صورت طی مراحل بالا هنگام اجرای برنامه و فراخوانی گزارشهای مربوطه با يك پيغام خطا روبرو خواهيد شد و گزارش مورد نظر شما نشان داده نخواهد شد دليل آن اين است كه نحوه ساخت Setup برای اين گونه برنامه ها كمی متفاوت است.

مراحل ساخت Setup برای اينگونه برنامه ها به اين شرح ذيل است:

ابتدا مراحل اوليه ساخت Setup را مانند برنامه های عادی طی كنيد.

پس از ساخت پروژه Setup در Solution Explorer روی آن كليك راست كرده و از منوی Add گزينه Merge Module را انتخاب كرده و آيتمهای زير را اضافه كنيد:

Crystal_Database_Access2003.msm
Crystal_Database_Access2003_enu.msm
Crystal_regwiz2003.msm

در Solution Explorer روی گزينه Crystal_regwiz2003.msm كليك راست كرده و Properties را انتخاب كنيد.

در پنجره Properties گزينه MergeModuleProperties را باز كرده و در قسمت License Key كد مربوطه را وارد كنيد.

توجه:

برای بدست آوردن Licence Key گزينه About از منوی Help در Visual Studio .NET را انتخاب كنيد سپس كدی كه در مقابل Crystal Reports for Visual Studio .NET نوشته شده را كپی كرده و در قسمت مربوطه وارد كنيد.

همه مقالات کليات ASP.NET را ببينيد.
جستجو: بگرد!
جستجوی پيشرفته
نام کاربری |
کلمه عبور |


IranASP.NET - چند زبانی در NET.

چند زبانی در NET.

لطفعلی خوش نفس | اين مقاله ۳۶۱۳ بار تاکنون ديده شده است.
۱۳۸۳/۳/۱۰ | برای وبلاگ برای وبلاگ
يکی از برتری‎های NET. نسبت به رقيب اين است که شما می توانيد از چندين زبان برنامه نويسی در يک برنامه استفاده نمائيد. حسن اين قابليت حداقل در اين است که افراد تيم برنامه نويسی شما مجبور نيستند که همگی تنها يک زبان را بدانند و شما هم بهتر و زودتر می توانيد تيم خود را تشکيل دهيد.

احتمالا به اين مطلب برخورد كرده ايد كه يكی از ادعاهای Microsoft در ارائه NET. چند زبانه بودن آن است. در اين مقاله می خواهيم اين موضوع را بررسی كنيم.

چند زبانه بودن به اين معنی است كه ما می توانيم قسمتهای مختلف يك برنامه را به زبانهای مختلف بنويسيم و آنها بدون هيچ مشكلی در كنار هم كار كنند. در NET. بدليل استفاده زبانها از كتابخانه كلاس NET. تفاوت آنها فقط در نحوه نوشتاری دستورات می باشد مثلا زبان #C هيچ برتری خاصی نسبت به VB.NET ندارد و انتخاب بين يكی از اين زبانها به سليقه و علاقه برنامه نويس بستگی دارد (البته من خودم VB را به دليل دارا بودن Syntax واضح تر ترجيح می دهم).

اما اگر می خواهيد همزمان از چند زبان استفاده كنيد مثال ساده زير شايد بتواند راهنمايی برای شما باشد. در مثال زير می خواهيم از زبانهای VB.Net و #C در يك برنامه Windows Application استفاده كنيم:

- ابتدا يك پروژه VB با نام MyvbProj در NET. ايجاد كنيد.

- سپس در Solution Explorer روی نام Solution كليك راست كرده و از منوی Add گزينه New Project را انتخاب كنيد.

- يك پروژه #C با نام MycsProj اضافه كنيد.

- حال در Solution Explorer روی پروژه Mycsproj كليك راست كرده و Properties را انتخاب كنيد.

- در پنجره باز شده Output Type را از Windows Application به Class Library تغيير دهيد.

- سپس در Solution Explorer روی نام Solution كليك راست كرده و گزينه Solution Build را انتخاب كنيد.

- حال در قسمت Referencese پروژه Myvbproj كليك راست كرده و گزينه Referencese Add را انتخاب كنيد.

- در پنجره باز شده به قسمت Projects رفته و Mycsproj را انتخاب و Select را انتخاب كنيد و Ok را بزنيد.

حال می توانيد در داخل پروژه VB از اجزای پروژه #C استفاده كنيد مثلا می توانيم با قرار دادن يك كنترل Button در فرم مربوط به پروژه VB و نوشتن كد زير برای رويداد كليك آن فرم مربوط به پروژه #C را نشان دهيم:

Dim Frm as new Mycsproj.Form1
Frm.ShowDialog(Me)

به همين روش شما می توانيد در يك برنامه از چندين زبان استفاده كنيد اين روش زمانی مفيد است كه يك تيم برنامه نويس روی يك برنامه كار می كنند و هر كدام از اعضا مايل به برنامه نويسی با يك زبان خاص می باشد.

همه مقالات کليات ASP.NET را ببينيد.
جستجو: بگرد!
جستجوی پيشرفته
نام کاربری |
کلمه عبور |


IranASP.NET - شئ گرايی در #C

شئ گرايی در #C

جعفر حيدری | اين مقاله ۴۵۳۴ بار تاکنون ديده شده است.
۱۳۸۳/۳/۱۸ | برای وبلاگ برای وبلاگ
دنيای برنامه نويسی امروزه بر مفهوم شئ گرايی استوار است. شئ گرايی به زبان ساده يعنی دنيا را آنطور ببنيم که هست! زبان #C يکی از بهترين زبانهايی است که دارای تمامی امکانات جهت پياده سازی مفاهيم اصيل شئ گرايی است. در اين مقاله با برخی مفاهيم مهم شئ گرايی از ديدگاه زبان #C آشنا می شويم. فراموش نکنيد که قبل از خواندن اين مقاله شما بايد با مفهوم کلاس و شئ آشنا باشيد.

شئ گرايی (OOP) در #C بر چند پايه استوار است که به قرار زيرند:

- Inheritance
- Encapsulation
- Polymorphism
- Abstraction
- Interface

اكنون به توضيح مختصر هر يک می پردازيم.

Inheritance (ارث بری)
پدر و فرزندی را در نظر بگيريد. هر پدری مشخصات فردی به خصوصی دارد. فرزند وی می تواند همه خصوصيات او را به ارث برد و خصوصيتهای ديگری نيز داشته باشد که پدرش ندارد. اين يعنی ارث بری! برای مثال پدر وقتی عصبانی می شود، داد و فرياد می كند. پسر هم اين خصوصيت را به ارث می برد با اين تفاوت كه وقتی عصبانی می شود، علاوه بر داد زدن، چند عدد بشقاب هم می شكند. در برنامه نويسی شئ گرا از مفهوم ارث بری استفاده های زيادی می شود. برای تفهيم راحت تر مسئله فرض کنيد کلاسی به نام وسيله نقليه داريم. از آنجا که هر وسيله نقليه ای حرکت می کند، رنگ دارد، سرعت دارد، ترمز می گيرد و... می توانيم همه اين متدها و فيلدها( کدام متدها و فيلدها!؟) را در کلاس وسيله نقليه تعريف کنيم. حال يک وهله از اين کلاس را در نظر بگيريد (مثلا دوچرخه!). يک دوچرخه يک وسيله نقليه است که همه خصوصيات عمومی يک وسيله نقليه را دارد و البته خصوصياتی دارد که مختص خودش هستند و در انواع ديگر يافت نمی شوند. به اين منظور اين دوچرخه می تواند ويژگيها و متدهای مشترک را از کلاس وسيله نقليه به ارث ببرد و در عين حال ويژگيهای منحصر به خود را نيز داشته باشد. قابليت استفاده دوباره از کد (Reusability) يکی از مزيات اصلی ارث بری است.

Encapsulation
همانطور كه از اسمش پيداست، به قرار دادن پياده سازی در يك كپسول اشاره می كند، به طوری كه كاربر بيرونی از نحوه پياده سازی مطلع نباشد و فقط بداند كه اين كپسول كار خاصی را انجام می دهد. وقتی يك کپسول می خوريد نمی دانيد که در داخل آن چه چيزی هست و فقط به اين فکر می کنيد که اين کپسول چه تاثيری در بدن شما می گذارد!

فرض کنيد سوار ماشينی هستيد که به سرعت در حرکت است! در مسيری که می رويد ماشين پدر نامزدتان از روبرو به شما نزديک می شود و سعی می کنيد سريع ترمز بگيريد تا برخورد نكنيد. اگر قرار باشد که بدانيد بعد از فشار دادن پدال ترمز چه عملياتی انجام می شود تا ترمز گرفته شود، ديگر بايد از ازدواج قطع اميد کنيد. ولی اگر تنها بدانيد که با فشار دادن پدال، ترمز گرفته می شود شما خوشبخت خواهيد شد. در واقع ما در اينجا کار ترمز گرفتن ماشين را به صورت يک کپسول آماده در نظر می گيريم. هدف Encapsulation اين است که ما را از پرداختن به ريز موضوعات رها کند و اشياء را به صورت يک جعبه سياهی بدانيم که به ازای يک ورودی خاص خروجی خاصی می دهند. اگر می خواهيم کدهای ما نيز اين مورد را رعايت کنند بايد سعی کنيم نگاه کپسولی به اشياء و عملکرد آنها داشته باشيم. در #C برای کپسوله کردن از Access Modifierهای protected ،private و public استفاده می شود.

Polymorphism
فرض كنيد پدر شما کار خاصی را به طريق خاصی انجام می دهد. مثلا برای پختن غذا (حقيقتی است تلخ!) اول ظرفهای ديشب را شسته و بعد گاز را روشن می کند و بعد غذا می پزد! شما که خصوصيات پدر و کارهای او را به ارث می بريد برای مثال برای پختن غذا ابتدا گاز را روشن می کنيد، بعد کبريت می کشيد، غذا را می پزيد و بعد ظرفهای ديشب را می شوييد! (توصيه می کنم نگذاريد ظرفهايتان نشسته بمانند!) برادر شما ممكن است همين كار را به طريق ديگری انجام دهد. پختن غذا کاری است که شما از پدر خود به ارث می بريد!!! ولی آن را به طريق ديگری انجام می دهيد. يعنی يک کار ثابت توسط فرزندان مختلف يک پدر به طرق مختلفی انجام می شود. اين دقيقا همان چيزی است که به آن چند شکلی يا Polymorphism می گويند.

Abstraction
تجريد يا مجرد سازی! به كلاسی مجرد گفته می شود كه پياده سازی متدها در آن انجام نمی شود! بر خلاف انسانها كه مجرد تعريف ديگری برايشان دارد! حال سئوالی پيش می آيد كه اگر کلاسی داشته باشيم که نخواهيم پياده سازی متدها را در آن انجام بديم، از آن كلاس چه استفاده ای می کنيم؟ برای پاسخ به اين سئوال شرايط زير را در نظر بگيريد:

فرض می کنيم که شما رييس يک شرکت بزرگ برنامه نويسی هستيد و می خواهيد پروژه بزرگی را انجام دهيد. برای اجرای پروژه از برنامه نويسان مختلفی استفاده می کنيد که ممکن است همه آنها هموطن نباشند! مثلا هندی، ايرانی يا آلمانی باشند! اگر قرار باشد هر برنامه نويسی در نامگذاری متدها و کلاسهايش آزاد باشد، در كد نويسی هرج و مرج به وجود می آيد. شما به عنوان مدير پروژه، کلاسی تعريف می کنيد که در آن تمام متدها با ورودی و خروجی هايشان مشخص باشند. ولی اين متدها را پياده سازی نمی کنيد و کار پياده سازی را به برنامه نويسان می دهيد و از آنها می خواهيد که همه کلاسهايی را که می نويسند از اين کلاس شما به ارث ببرند و متدها را به طور دلخواه پياده سازی کنند. اين باعث می شود که شما با داشتن يک کلاس، ورودی و خروجی های مد نظر خود را داشته باشيد و ديگر نگران برنامه نويسان نباشيد. کلاسی که شما تعريف می کنيد يک کلاس مجرد ناميده می شود.

برای تعريف يک کلاس مجرد از کلمه کليدی abstract استفاده می کنيم. فيلدهايی که می خواهيم در کلاسهای مشتق شده از اين کلاس پياده سازی شوند حتما بايد با abstract تعريف شوند. يک کلاس مجرد می تواند فيلدها و متدهای نامجرد داشته باشد. اگر متد نامجردی در يک کلاس مجرد تعريف کرديد، حتما بايد آن را پياده سازی کنيد و نمی توانيد پياده سازی آن را به کلاسهای مشتق شده بسپاريد.

Interface
اينترفيس در برنامه نويسی همانند همان کلاس است تنها با اين تفاوت که هيچکدام از اعضای آن پياده سازی نمی شوند. در واقع يک اينترفيس گروهی از متدها، خصوصيات، رويدادها و Indexer ها هستند که در کنار هم جمع شده اند. اينترفيس ها را نمی توان Instantiate (وهله سازی) کرد (يعنی نمی توان وهله ای از يک اينترفيس ايجاد کرد!). تنها چيزی که يک اينترفيس دارا می باشد امضای (signature) تمامی اعضای آن می باشد. به اين معنی که ورودی و خروجی متدها، نوع Property ها و... در آن تعريف می شوند ولی چيزی پياده سازی نمی شود. اينترفيس ها سازنده و فيلد ندارند (امری است بديهی! چرا؟). يک اينترفيس نمی تواند Operator Overload داشته باشد و دليل آن اين است که در صورت وجود اين ويژگی، احتمال بروز مشکلاتی از قبيل ناسازگاری با ديگر زبانهای NET. مانند VB.NET که از اين قابليت پشتيبانی نمی کند وجود داشت. نحوه تعريف اينترفيس بسيار شبيه تعريف کلاس است تنها با اين تفاوت که در اينترفيس پياده سازی وجود ندارد.

حالا اين اينترفيس در كجا به كار می آيد؟ اگر با ++C کار کرده باشيد ( در آن صورت کارتان خيلی درست می باشد!!!) با واژه ارث بری چند گانه آشنا هستيد. ولی احتمالا شنيديد که جاوا و #C از ارث بری چندگانه پشتيبانی نمی کنند. (يعنی يک کلاس از چند کلاس ديگر به ارث ببرد). گاهی لازم داريم از چند کلاس به ارث ببريم. راه حلش اين است که از اينترفيس ها استفاده کنيم. ولی بدانيد که اگر از اينترفيسی به ارث برديد بايد تمام متدهای آن را پياده سازی کنيد. يک کلاس می تواند از n تا اينترفيس و تنها يک کلاس به ارث ببرد.

همه مقالات آشنايی با #C را ببينيد.
جستجو: بگرد!
جستجوی پيشرفته
نام کاربری |
کلمه عبور |


IranASP.NET - چهار روش برای نمايش محتوای DataSet در فرمهای وب

چهار روش برای نمايش محتوای DataSet در فرمهای وب

احسان وليزاده | اين مقاله ۴۳۶۵ بار تاکنون ديده شده است.
۱۳۸۳/۳/۲۷ | برای وبلاگ برای وبلاگ دريافت کد
در ADO.NET دو روش برای کار با داده ها وجود دارد: DataSet و DataReader. هر کدام از اين دو روش موارد استفاده خود را دارند. اگر هدف نشان دادن سريع داده هاست DataReader مناسب تر از DataSet می باشد ولی اگر قصد انجام عملياتی بر روی داده ها داريد و لازم است داده ها در حافظه مقيم شوند بايد از DataSet استفاده کنيد. در اين مقاله چهار روش برای نمايش محتوای يک DataSet در فرمهای وب بيان می شود.

وقتی از DataSet استفاده می کنيد بدليل انبار شدن داده ها در حافظه، استفاده نادرست از آن می تواند سرعت و کارايی برنامه وب شما را کاهش دهد، البته استفاده نادرست از DataSet در برنامه های ويندوز هم تاثير منفی در کارايی برنامه دارد ولی مسلما به اندازه برنامه های وب محسوس نيست و اين بدليل آن است که در برنامه های وب امکان انجام درخواستهای همزمان از يک صفحه وجود دارد.

در اين مقاله چهار روش برای نمايش محتوای يک DataSet در فرمهای وب بيان می شود:

۱- استفاده از کنترل DataGrid
۲- استفاده از کنترل DataList
۳- استفاده از کنترل Repeater
۴- استفاده از يک متغير

هر DataSet می تواند يک يا چندين DataTable را شامل شود. برای وارد کردن داده ها به داخل DataSet نياز به استفاده از يک DataAdapter داريم. انجام مراحل زير برای وارد کردن داده ها در DataSet اساسی هستند:

• ايجاد يک Connection به پايگاه داده:

Dim strConn as string = “initial catalog=Northwind;integrated security=SSPI;persist security info=False;workstation id=DOTNET"
Dim MyConn as New SQLConnection(strConn)

• ايجاد DataSet:

Dim ds as DataSet=New DataSet()

• ايجاد DataAdapter:

Dim MySQL as string = "Select Employees.FirstName, Employees.LastName, Employees.Title from Employees"
Dim da as New SQLDataAdapter(MySQL,MyConn)

• بعد از انجام اين مراحل متد Fill از شئ DataAdapter را فراخوانی می کنيم:

da.Fill(ds,"Employees")

پارامتر اول در اين متد نام DataSet و پارامتر دوم نام DataTable جديدی است که می خواهيم تعريف کنيم.

اکنون DataSet شامل داده هايی می باشد که از DataAdapter به داخل آن انتقال يافته اند. برای نشان دادن داده های داخل DataSet از يکی از روشهای زير استفاده می کنيم:

۱- کنترل DataGrid
با استفاده از کد زير می توان جدول Employees را (که در داخل DataSet قرار دارد) در DataGrid نشان داد:

MyDataGrid.Datasource=ds.Tables("Employees").DefaultView
MyDataGrid.DataBind()

همانطور که مشاهده می کنيد ابتدا با مشخص نمودن خصوصيت Datasource کنترل DataGrid - که جدول Employees واقع در DataSet می باشد - داده ها به داخل DataGrid انتقال می يابند و سپس با فراخوانی متد DataBind داده ها بر روی صفحه نشان داده می شوند.

۲- کنترل DataList
برای مقيد کردن داده ها بر روی کنترلهای DataList و Repeater نيز همانند کنترل DataGrid می توانيد کدهای زير را بکار ببريد:

MyDataList.Datasource=ds.Tables("Employees").DefaultView
MyDataList.DataBind()

۳- کنترل Repeater

MyRepeater.datasource = ds.Tables("Employees").DefaultView
MyRepeater.DataBind()

کنترلهای DataGrid ،DataList و Repeater کنترلهای DataBound نام دارند. کنترلهای DataBound امکان تنظيم منابع داده را به صورت Programmatically فراهم می کنند. اين کنترلها بعد از تنظيم منبع داده ای بر روی آن تکرار شده و بر اساس فرمت تعيين شده برای کنترل، داده ها را نمايش می دهند. فرمت فقط برای يک سطر مشخص می شود و همه سطرها بر اساس آن نشان داده می شوند.

این که کدام کنترل را برای نمايش داده ها انتخاب کنيد به اين بستگی دارد که می خواهيد چه مقدار کنترل بر روی فرمت نمايش داده ها داشته باشيد. کنترل DataGrid آسانترين و ساده ترين راه برای به نمايش درآوردن داده ها در قالب يک جدول است. Visual Studio .NET هم قالب های آماده ای را از طريق گزينه Auto Format برای تغيير ظاهری کنترل DataGrid (و همچنين DataList) در اختيار ما قرار می دهد. DataList کمی پيچيده تر از DataGrid است ولی امکان کنترل زيادی را در رابطه با فرمت بندی از طريق استفاده از الگوها فراهم می کند. کنترل Repeater نسبت به DataList هم پيچيده تر است و می توان کنترل خيلی بيشتری را هنگام استفاده از الگوها بر روی فرمت نمايش داده ها اعمال نمود.

به دليل اين که کنترلهای DataList و Repeater به طور پيش فرض فرمت داخلی ندارند هنگام تعريف بايد آنها را فرمت بندی نماييم (فرمت کنترل DataGrid را هم می توان تغيير داد ولی اگر تغيير ندهيم مشکلی پيش نمی آيد و داده ها نمايش داده می شوند). به عنوان نمونه برای کنترل DataList می توان چنين نوشت:

<asp:DataList id="MyDataList" runat="server" GridLines="None" cellpadding="2" cellspacing="2" Headerstyle-BackColor="#8080C0" Headerstyle-Font-Name="Arial" Headerstyle-Font-Size="8" Font-Name="Arial" Font-Bold="false" Font-Size="8">
<ItemTemplate>
<%# DataBinder.Eval(Container.DataItem, "firstname") %> <%# DataBinder.Eval(Container.DataItem, "lastname") %> - <b><i><%#DataBinder.Eval(Container.DataItem, "Title") %> </i></b>
</ItemTemplate>
</asp:DataList>

DataBinder.Eval متدی است که برای ارزيابی عبارات data-binding در زمان اجرا از آن استفاده می شود. ساختار اصلی اين متد به صورت زير است:

<%# DataBinder.Eval(Container, EvalExpression, FormatExpression) %>

Container عبارتی را بيان می کند که می خواهيم ارزيابی کنيم، برای کنترلهای DataBound هميشه مقدار Container.DataItem را به جای Container قرار می دهيم. EvalExpression نام خصوصيت يا آيتمی است که بايد ارزيابی شود و FormatExpression يک عبارت با فرمت رشته ای است که برای فرمت کردن نتيجه که يک رشته است استفاده می شود.

۴- استفاده از متغير برای نشان دادن محتوای DataSet
برای نشان دادن محتوای DataSet می توان تکنيک استفاده از متغير را بکار برد. برای اين کار ابتدا محتوای DataSet را در يک متغير از نوع String قرار می دهيم. کد لازم برای انجام اين کار به صورت زير است:

Dim sEmps as String
Dim dr As DataRow
For Each dr In ds.Tables("Employees").Rows
sEmps += "<b>" & dr("firstname") & " " & dr("lastname") & " </b> - " & dr("Title") & "<br>"
Next

روشی که در اينجا استفاده شده است پيمايش تمام سطرهای جدول مورد نظر با استفاده از يک حلقه For Each … Next است که همه آنها را در داخل متغير از نوع String قرار می دهد. سپس خصوصيت text يک کنترل literal را برابر اين متغير قرار می دهيم:

litEmps.text=sEmps

برنامه آماده مربوط به مقاله را می توانيد از بالای همين صفحه دريافت نماييد.

همه مقالات فرم های وب را ببينيد.
جستجو: بگرد!
جستجوی پيشرفته
نام کاربری |
کلمه عبور |


IranASP.NET - مديريت نقش ها با استفاده از Generic Principle و FormsAuthentication

مديريت نقش ها با استفاده از Generic Principle و FormsAuthentication

بهنام يوسفی شمالی | اين مقاله ۳۱۲۲ بار تاکنون ديده شده است.
۱۳۸۳/۴/۹ | برای وبلاگ برای وبلاگ
مديريت در سايت های دارای بخش کاربران و کلا سايت هايی که به نوعی احتياج به طبقه بندی دسترسی ها به بخش های مختلف سايت دارند، با اين بحث آشنا هستند.در اين مقاله به شکل عملی به شرح نحوه ی استفاده از امکانت ASP.NET برای کار با نقش ها می پردازيم.

برای مديريت نقش ها در اين روش نخست بايد در استفاده از FormsAuthentication مسلط باشيد.

با ساخت يک WebApplication شروع می کنيم. صفحه Logon يادتان نرود! مسير کار به اين شرح است:

1. Web.Config را برای FormsAuthentication تغيير می دهيم.
2. تهيه‎ی يک Ticket برای شناسايی کاربر
3. ساخت اشياء GenericPrincipal و FormsIdentity
4. آزمايش برنامه

1. در Web.Config بخش <authentication> را به شکل زير تغيير دهيد:

<"authentication mode="Form>
<forms name="TestCookie " loginUrl= "login.aspx" protection="All" timeout="30" path="/"></forms>
</authentication>

المنت <authorization> زير را پايين بخش <authentication> اضافه کنيد.

<authorization>
<deny users="?" />
<allow users="*" />
</authorization>

2. ساخت يک Ticket شناسايی برای کاربر
Ticket شناسايی در واقع نوعی کوکی است که ماژول FormsAuthentication برای شناسايی استفاده می کند.

در مرحله اول بايد اطلاعات کاربر (شناسه و کلمه عبور) را تاييد کنيد. روش اين کار کاملا سليقه ای است. می توانيد از پايگاه داده يا از Web.Config استفاده کنيد. در هر صورت شما به يک Function مانند زير نياز داريد:

Function IsAuthenticated(ByVal uid As String,ByVal pwd As String)As Boolean
. . .
Return true
End Function

مطمئنا وقتی می خواهيد نقش ها را مديريت کنيد، برای هر کاربر در پايگاه داده ها نقش ها را نيز مشخص کرده ايد. پس يک Function هم بايد وظيفه ی بازگرداندن نقش ها را به عهده داشته باشد. مانند زير:

Function GetRoles(ByVal uid As String,ByVal pwd As String)As Boolean
. . .
Return "Admin|Moderator|Manager"
End Function

در صفحه‎ی Logon.aspx درون کد Button اين کدها را بنويسيد:

If dp.Authenticate(Trim(txtuid.Text), Trim(txtpwd.Text)) Then
Dim strRoles As String = dp.GetRoles(Trim(txtuid.Text) , Trim(txtpwd.Text))
Dim Roles() As String = Split(strroles,"|")
Dim authTicket As New FormsAuthenticationTicket(1, Trim(txtuid.Text), Now(), Now.AddMinutes(60), False, Roles)
Dim encryptedTicket As String = FormsAuthentication.Encrypt(authTicket)
Dim authCookie As New HttpCookie(FormsAuthentication.FormsCookieName, encryptedTicket)
Response.Cookies.Add(authCookie)
Response.Redirect(FormsAuthentication.GetRedirectUrl(Trim(txtuid.Text), False))

3. ساخت اشياء GenericPrincipal و FormsIdentity
صفحه‎ی کدهای Global.asax را باز کنيد و در قسمت بالای کد اين قسمت را اضافه کنيد:

Imports System.Web.Security
Imports System.Security.Principal

در بخش Application_AuthenticateRequest کد های زير را اضافه کنيد.

Dim cookieName As String = FormsAuthentication.FormsCookieName
Dim authCookie As HttpCookie = Context.Request.Cookies(cookieName)

If authCookie Is DBNull.Value Then
' There is no authentication cookie.
Return

End If

بخش زير را برای رمزگشايی کوکی اضافه کنيد:

Dim authTicket As FormsAuthenticationTicket
Try

authTicket = FormsAuthentication.Decrypt(authCookie.Value)

Catch ex As Exception
‘ Log exception details (omitted for simplicity)
Return
End Try

If authTicket Is DBNull.Value Then
‘ Cookie failed to decrypt.
Return
End If

اين بخش را برای بازيافت نقش ها اضافه کنيد:

Dim roles As String() = authTicket.UserData.Split("|")

اين بخش را برای ساخت FormsIdentity با شناسه ای که از کوکی گرفته شده و ساخت GenericPrincipal که شامل اين Identity است، اضافه کنيد:

' Create an Identity object
Dim id As New FormsIdentity(authTicket)

' This principal will flow throughout the request.
Dim principal As New GenericPrincipal(id, roles)
' Attach the new principal object to the current HttpContext object
Context.User = principal

5. برای آزمايش برنامه اين کد ها را در صفحه Test.aspx بنويسيد:
در ابتدا

Imports System.Security.Principal

و سپس در کد Load صفحه:

Dim p As IPrincipal = HttpContext.Current.User
Response.Write("Authenticated Identity is: " + p.Identity.Name)
Response.Write("<p>")
If p.IsInRole("admin") Then
Response.Write("RoleName is: Admin")
End If

منابع:
کتاب Building Secure Microsoft ASP.NET Applications

همه مقالات کليات ASP.NET را ببينيد.
جستجو: بگرد!
جستجوی پيشرفته
نام کاربری |
کلمه عبور |


IranASP.NET - فارسی سازی Text.

فارسی سازی Text.

مديريت سايت | اين مقاله ۵۳۲۶ بار تاکنون ديده شده است.
۱۳۸۳/۴/۱۶ | برای وبلاگ برای وبلاگ
يکی از خوانندگان وبلاگ ايميل زده بود که چگونه می توان Text. را فارسی کرد يا به عبارت ديگر من اين کار را چگونه انجام داده ام؟ فکر کردم که شايد اين موضوع برای شما هم سوال باشد، لذا تصميم گرفتم اندکی به اين مطلب بپردازم شايد برای همه مفيد باشد. يادآوری اينکه وبلاگ سايت IranASP.NET از نسخه فارسی شده Text. استفاده می کند که نام آن را P.Text مخفف Persian .Text گذاشته ام.

توضيح: اين مطلب را ابتدا برای وبلاگ نوشته بودم اما از آنجا که حجم آن زياد شد و شکل مقاله به خودش گرفت تصميم گرفتم که با اندکی تغييرات آن را به صورت مقاله در سايت منتشر کنم. در نتيجه مطلب زير لزوماً دارای نثر رسمی نمی باشد.
يکی از خوانندگان وبلاگ ايميل زده بود که چگونه می توان Text. را فارسی کرد يا به عبارت ديگر من اين کار را چگونه انجام داده ام؟ فکر کردم که شايد اين موضوع ممکن است سوال شما هم باشد، لذا تصميم گرفتم اين مطلب را البته به طور خيلی خلاصه اينجا بنويسم شايد برای همه مفيد باشد. البته اين توضيح را بدهم که واقعاً مايل نيستم که درگير بحث دات تکست و يا فارسی سازی آن بشوم. فارسی سازی دات تکست حداقل در حال حاضر برای من صرفاً جنبه يک تجربه‎ی شخصی را دارد و هيچ برنامه يا طرحی برای آن نداشته ام و اصولا وقت از اين بيشتر پرداختن به آن را هم ندارم (حالا باز يک عده ای می گويند که طرف دارد دوباره کلاس می گذارد! ولی بخدا اينطور نيست).

اول اينکه Text. يا دات تکست که يک ابزار وبلاگ نويسی است چيزی نيست جز يک برنامه‎ی ASP.NET که توسط آقای Scott Watermasysk البته با مهارت و دقت بالايی نوشته شده است. فکر می کنم هدف ايشان در ابتدا اين بوده است که چگونه می توان با استفاده از ASP.NET يک ابزار وبلاگ نويسی نوشت. من دقيقا اولين روز آن را به ياد می آورم. صفحه ای بسيار ساده و در حد يک وبلاگ شخصی بود که بعداً افراد ديگری به آن اضافه شدند و اسکات واتر نيز مجبور شد چند بار آن را بازنويسی کند تا به نسخه فعلی برسد. به هر حال امروزه دات تکست معروف ترين ابزار وبلاگ نويسی مبتنی بر فناوری شرکت معظم مايکروسافت است.

البته اين مساله نمی تواند دليلی بر اين باشد که دات تکست بهترين ابزار در نوع خود می باشد. چنانکه می دانيد ابزارهای زيادی امروزه برای وبلاگ نويسی وجود دارد که برخی همانند Movable Type حتی شايد بهتر و در نتيجه رايج تر، آسان تر و پر امکانات تر هم باشند. دات تکست شايد بيشتر از نگاه برنامه نويسان وب و کسانی که در اين زمينه به خصوص ASP.NET فعاليت دارند مهم باشد والا از ديدگاه يک استفاده کننده‎ی معمولی چه فرقی می کند که چنين ابزاری با کدام فناوری نوشته شده است؟

پس از اين مقدمه طولانی برويم سراغ اصل مطلب که فکر کنم حجم آن خيلی بيشتر از اين مقدمه نباشد! (گفته بودم که خيلی مايل نيستم وارد جزئيات شوم). اصولا فارسی سازی دات تکست يک برنامه نويسی از صفر نيست بلکه شما بايد برنامه موجود را اندکی تغيير دهيد. بديهی است که قبل از هر چيزی شما بايد يک ASP.NET کار خيلی خوب باشيد. يعنی بتوانيد حداقل سورس آن را خوانده و بفهميد که طرف چگونه عمل کرده است و در هر کجا منظورش چه بوده است. بدون داشتن چنين توانايی اصلا سراغ چنين کاری نرويد چون وقت تان را تلف خواهيد کرد.

بايد بر SQL Server مسلط باشيد، مدل برنامه نويسی لايه ای را خوب فهميده و کار کرده باشيد، شئ گرايی را شديداً بدانيد، ASP.NET را خورده باشيد و نيز حوصله نسبتاً خوبی هم داشته باشيد. دات تکست برنامه سختی نيست ولی خيلی هم ساده نيست. باور کنيد خود من هنوز يک سری بخش هايش را اصلاً نفهميده ام. ولی در عوض نگران نباشيد چون احتمالاً شما نيازی به تغييرات در چنين قسمتهايی را نخواهيد داشت (اگر چه فکر می کنم برای تکميل اين کار و فارسی سازی صددرصدی آن نياز دارم که آن قسمتهای سخت را هم خوب بفهمم). اين را هم دقت داشته باشيد که خواندن و فهميدن سورس دات تکست خود يک کلاس آموزشی بسيار مفيد و البته سطح بالا است. خواندن آن را برای افراد متوسط به پائين توصيه نمی کنم.

دات تکست به گونه ای طراحی شده است که به راحتی می توان آن را به هر زبانی محلی کرد. منتها اوايل کار به مشکلی برخورد کردم که اين اصل را نقض می کرد. مشکل اين بود که متون فارسی به صورت علامت سوال نشان داده می شد (اين اشکال را خيلی ها به نوعی ديگر در تماس با من در ارتباط با برنامه های خودشان نيز دارند). با Scott Water تماس گرفتم ولی او هم در اين مورد نظری نداشت و راه حلی پيدا نکرد. بالاخره خودم توانستم ايراد کار را پيدا کنم. ايراد در کد نويسی آقای Scott Water بود. البته شايد نتوان گفت که ايراد بود چون ايشان اين برنامه را با ذهنيت بين المللی ننوشته بود و صرفا از زبان انگليسی به آن نگاه کرده بود. مشکل آنجا بود که اگر چه ايشان از تايپ ntext در طراحی پايگاه داده استفاده کرده بود ولی در هنگام ارسال پارامترها به stored procedure های مربوطه (که يکی دو تا هم بيشتر نيستند) از تايپ text استفاده می کرد. لذا برنامه ای که قابليت یونيکد را داشت عملاً و به اشتباه اين قابليت از آن گرفته شده بود.

اين توضيح را هم بدهم که فارسی سازی يعنی فارسی سازی همه چيز! مثلا برای من وجود تاريخ ميلادی در يک "وبلاگ فارسی" قابل قبول نيست.

فرآيند فارسی سازی دات تکست به طور کلی شامل موارد زير است:

1- مقادير متنابهی راست به چپ کردن صفحات چه از لحاظ چيدمان صفحات و چه از لحاظ افزودن تعداد زيادی dir=rtl
2- تبديل کليه تاريخ های ميلادی به تاريخ شمسی. در اين راستا مقاله و کلاس pcal دوست عزيزمان اميد خندان راد را فراموش نکنيد.
3- تبديل ساعت مانند تبديل PM به ب.ظ
4- تبديل کليه اعداد به فارسی (فکر کنم در اين مورد اختلاف نظر وجود دارد)
5- ترجمه تعداد اندکی عبارات ساده از انگليسی به فارسی
6- يک سری تغييرات جزئی ولی خيلی مهم در لايه Data Access در مورد بکارگيری صحيح تايپ ntext و text (اين يکی فوت کوزه گری است که در بالا هم به آن اشاره کرده ام، بگرديد پيدايش کنيد!)
7- فارسی کردن حداقل يکی از قالب های (Skin) موجود (شامل برخی تغييرات در فايل های CSS و نيز فايلهای config هم هست)
8- يادداشت کردن کليه تغييراتی که انجام می دهيد.

اين مورد آخری خيلی مهم است (من خودم توانستم بيش از چهل مورد تغيير را يادداشت کنم). کل کار برای من تا نسخه همزمان با تاريخ انتشار اين مقاله دو روز وقت برده است. در ضمن حواستان باشد که حداقل تغييرات را بايد اعمال کنيد چون نسخه های بعدی اين برنامه در راه است. شايد مجبور شويد همه کارهای فوق را دوباره بر روی نسخه جديد هم انجام دهيد!

همچنين توجه داشته باشيد که من هيچ گونه تغييری را در قسمت مديريت وبلاگ در نظر نگرفته ام و از همان نسخه اصلی و انگليسی آن استفاده می کنم و به مشکلی هم برخورد نکرده ام. اگر خواستيد می توانيد آن را هم فارسی کنيد ولی به نظر من برای استفاده شخصی ارزش وقت صرف کردن ندارد.

باز هم تکرار می کنم که کليد اعمال تغييرات در هر برنامه ای، فهم کامل آن است. لذا به دنبال فرمول جادويی در اين ارتباط نباشيد. سورس را به دست گرفته و مشغول خواندن آن شويد و کمی هم عرق بريزيد!

می دانم که هنوز خيلی سوال داريد و من چيز خاصی نگفته ام ولی باور کنيد از اين بيشتر وقتش را نداشته ام (نگوئيد داری دوباره کلاس میگذاری!). همچنين قول نمی دهم که به سوالات تان جواب دهم ولی سعی می کنم به بعضی از آنها اگر توانستم تلگرافی پاسخ دهم. بسياری از سوالات شما در مورد خود دات تکست در فروم مربوطه و نيز در سايت Wiki احتمالاً جواب داده شده است.

لينکهای مهم در ارتباط با Text.

سورس Text.
فروم Text.
راهنمای Text.
مجوز و کپی رايت Text.

همه مقالات فارسی در وب را ببينيد.
جستجو: بگرد!
جستجوی پيشرفته
نام کاربری |
کلمه عبور |


IranASP.NET - کاهش حجم خروجی در ASP.NET

کاهش حجم خروجی در ASP.NET

کيوان نيّری | اين مقاله ۴۰۷۰ بار تاکنون ديده شده است.
۱۳۸۳/۵/۵ | برای وبلاگ برای وبلاگ
مساله سرعت بارگذاری صفحات چه به صورت ايستا طراحی شده باشند و چه به صورت پويا از مباحث مهم در طراحی حرفه ای صفحات وب است اين مساله در کشور ما با توجه به سرعت نسبتا پايين خطوط اينترنت اهميت مضاعفی می يابد از طرفی در سايتهای بزرگ که طبعا حجم بيشتری هم دارند مساله پهنای باند مصرفی نيز مورد توجه قرار می گيرد که رابطه مستقيمی با سرعت بارگذاری صفحات دارد چرا که سرعت بارگذاری صفحات نيز رابطه مستقيمی با حجم صفحات دارد.

مساله سرعت بارگذاری صفحات (چه به صورت Static طراحی شده باشند چه به صورت Dynamic) از مباحث مهم در طراحی حرفه ای صفحات وب است اين مساله در کشور ما با توجه به سرعت نسبتا پايين خطوط اينترنت اهميت مضاعفی می يابد از طرفی در سايتهای بزرگ که طبعا حجم بيشتری هم دارند مساله پهنای باند مصرفی نيز مورد توجه قرار می گيرد که رابطه مستقيمی با سرعت بارگذاری صفحات دارد چرا که سرعت بارگذاری صفحات نيز رابطه مستقيمی با حجم صفحات دارد.

در واقع عامل اصلی در سرعت بارگذاری صفحات حجم کدهای HTML صفحات است. صفحات چه به صورت Static طراحی شده باشند چه به صورت Dynamic در نهايت به صورت کدهای HTML در سمت Client به نمايش در می آيند. اگر چه در صفحات Dynamic ميزان محاسبات روی Server نيز نقش دارند ولی با توجه به رشد قدرت سخت افزار و نرم افزار اين عامل روز به روز کم رنگ تر می شود.

حال بحث را به ASP.NET محدود می کنيم. اگر با ساختار پاسخ گويی به درخواستهای کاربران توسط IIS در ASP.NET آشنا باشيد، می دانيد که پس از پردازش کدهای صفحات و تعيين کدهای HTML آنها را به سمت Client می فرستد. حال برای حل مشکل سرعت صفحات حجيم راه حل هايی ايجاد شده است که ريشه در فشرده سازی و کاهش حجم کدهای HTML ارسالی به سمت کاربر و بازگشايی کدهای HTML در سمت Client دارد.

روشهای بسيار قوی و توانايی در اين زمينه وجود دارند که می توانند تا متوسط هشتاد درصد در سرعت و پهنای باند مصرفی صرفه جويی کنند. و بسته های نرم افزاری آنها در سايتهای داخلی و خارجی موجودند(مانند بسته نرم افزاری ASP.JET). ولی سوالی که مطرح می شود اينست که بازگشايی کدهای فشرده شده در سمت Client بر چه اساسی صورت می گيرد؟ پاسخ اين است که در استاندارد HTTP 1.1 الگوريتمهای به صورت پيش فرض برای فشرده سازی صفحات در نظر گرفته شده اند که فشرده سازی نيز توسط همين الگوريتمها صورت می گيرد.

مقاله پيش روی شما به روشی می پردازد که جدا از مساله بازگشايی کدهای فشرده سازی شده است. پس در استاندارد HTTP 1.0 نيز قابل استفاده است ولی درصد کمتری از فشرده سازی را نسبت به روشهای مذکور انجام می دهد (بين 7 تا 30 درصد).
می دانيم در طراحی کدهای HTML در اکثر نرم افزارهای طراحی Editor ها برای خوانايی کدها و خطايابی، آنها را با فواصل و شکست خطوط مناسبی به نمايش گذاشته و به همين صورت نيز ذخيره می کند. اين فواصل اضافی توسط مرورگرها در نظر گرفته نمی شوند ولی حجم زائدی را اشغال می کنند. در اين مقاله با استفاده از يک کلاس نوشته شده در Visual Basic.NET اين فواصل را پيش از ارسال کدهای HTML به سمت Client از بين می برد و از فوايد اين روش اين است که برای سايتهای کوچکتر و وبلاگها به سهولت قابل استفاده است و در صورتی که در سايتهای بزرگ Client ها از استاندارد HTTP 1.0 استفاده کنند می توانند با استفاده از اين روش خلا موجود را تا حدی پوشاند.

در اينجا ذکر اين نکته لازم است که الگوريتمهای مورد استفاده در فشرده سازی صفحات نمی توانند کدهای حاصل از روش موجود در اين مقاله را فشرده کنند و حاصل کدهايی خواهد بود که در مرورگر به نمايش در نمی آيد زيرا اين روشها بر مبنای شکست خطوط و فواصل پيش فرض واقعند. در صورتی که قصد استفاده از اين روشها را در کنار هم داريد لازم است روش زير را توسط شروط لازم به استاندارد HTTP 1.0 محدود کنيد.

نکته قابل توجه ديگر اين است که کلاس به کار رفته در اين مقاله تعدادی از فواصل زائد موجود در Tag ها و کدهای معمول را حذف می کند و شما به سادگی می توانيد مطابق الگوی به کار رفته Tag ها و کدهای ديگری را به اين کلاس اضافه کنيد.

روش استفاده:

اين مقاله از فضای نام HttpResponse.Filter برای کاهش حجم خروجی استفاده می کند. برای استفاده از اين الگوريتم لازم است که کد کلاس WhitespaceFilter موجود در زير را در يک فايل به نام WhitespaceFilter.vb ذخيره نموده و به پروژه خود اضافه کنيد و خط زير را به متد Application_BeginRequest در فايل Global.asax اضافه کنيد:

Sub Application_BeginRequest(ByVal sender As Object, ByVal e As EventArgs)

        ' Fires at the beginning of each request

        Response.Filter = New WhitespaceFilter(Response.Filter)

End Sub

در صورتی که هدف شما استفاده از اين روش در صفحات خاصی است کافيست به جای عمل فوق کد بالا را در متد Load صفحات هدف اضافه کنيد با کد موجود در فايل Global.asax را مانند مثال زير با شروط لازم تغيير دهيد:

Sub Application_BeginRequest(ByVal sender As Object, ByVal e As EventArgs)

      ' Fires upon attempting to authenticate the use

      If Request.Url.PathAndQuery.ToLower.IndexOf("makethumbnail") = -1 Then

            Response.Filter = New WhitespaceFilter(Response.Filter)

      End If

End Sub

بهتر است برای مقايسه حجم صفحات HTML خود قبل از استفاده از اين روش يکی از صفحات خود را در مرورگر مشاهده کرده و توسط يک Editor مانند NotePad محتوای آن را بررسی کنيد و آن را به صورت يک فايل متنی ذخيره کنيد.سپس بعد از استفاده از اين روش همان صفحه را مجددا بررسی کرده و به صورت فايل ديگری ذخيره سازی کنيد.بعد از آن حجم دو فايل را با هم مقايسه کنيد تا برای هر صفحه به درصد فشرده سازی صفحات پی ببريد.

بررسی کدهای کلاس WhitespaceFilter:

حال به بررسی کدهای مربوط به اين Class می پردازيم:

Imports System.IO

Imports System.Text.RegularExpressions

اين فيلتر از ايجاد فضاهای خالی غير ضروری د رخروجی جلوگيری می کند:

' This filter gets rid of all unnecessary whitespace in the output.

Public Class WhitespaceFilter

    Inherits Stream

    Private _sink As Stream

    Private _position As Long

    Public Sub New(ByVal sink As Stream)

        _sink = sink

    End Sub 'New

اين قسمت از کد در صورت ايجاد هر گونه تغيير نبايد تغيير کند.

#Region " Code that will most likely never change from filter to filter. "

اين اعضا از Stream مهم هستند.

    ' The following members of Stream must be overridden.

    Public Overrides ReadOnly Property CanRead() As Boolean

        Get

            Return True

        End Get

    End Property

    Public Overrides ReadOnly Property CanSeek() As Boolean

        Get

            Return True

        End Get

    End Property

    Public Overrides ReadOnly Property CanWrite() As Boolean

        Get

            Return True

        End Get

    End Property

    Public Overrides ReadOnly Property Length() As Long

        Get

            Return 0

         End Get

    End Property

    Public Overrides Property Position() As Long

        Get

            Return _position

        End Get

        Set(ByVal Value As Long)

            _position = Value

        End Set

    End Property

    Public Overrides Function Seek(ByVal offset As Long, ByVal direction As System.IO.SeekOrigin) As Long

        Return _sink.Seek(offset, direction)

    End Function 'Seek

    Public Overrides Sub SetLength(ByVal length As Long)

        _sink.SetLength(length)

    End Sub 'SetLength

    Public Overrides Sub Close()

        _sink.Close()

    End Sub 'Close

    Public Overrides Sub Flush()

        _sink.Flush()

    End Sub 'Flush

    Public Overrides Function Read(ByVal MyBuffer() As Byte, ByVal offset As Integer, ByVal count As Integer) As Integer

        _sink.Read(MyBuffer, offset, count)

    End Function

#End Region

Write متد اصلی انجام عمل فيلتر است.

    ' Write is the method that actually does the filtering.

    Public Overrides Sub Write(ByVal MyBuffer() As Byte, ByVal offset As Integer, ByVal count As Integer)

        Dim data(count) As Byte

        Buffer.BlockCopy(MyBuffer, offset, data, 0, count)

اينجا ASCII Encoding استفاده نکنيد چون IDE برخی ار کاراکترها مثل ® را با کاراکترهای UTF-8 عوض می کنند اگر از ASCII Encoding استفاده کنيد B را به جای علامت ® دريافت می کنيد.

        ' Don't use ASCII encoding here.  The .NET IDE replaces some characters, such as &reg;

        ' with a UTF-8 entity.  If you use ASCII encoding, you'll get B. instead of the registered

        ' trademark symbol.

        Dim s As String = System.Text.Encoding.UTF8.GetString(data)

جا به جا کردن کاراکترهای موجود در کنترلها با فضاهای خالي.

بررسی Semi-colon در اين قسمت به علت وجود اين کاراکتر در توضيحات Java Script موجود در کامپوننت است.

با اين راه ما مقدار را حفظ می کنيم.

        ' Replace control characters with either spaces or nothing

        ' The funky semi-colon handling is there because of a JavaScript comment in a component.

        ' This way, we keep the carriage returns that actually matter.

        s = s.Replace(ControlChars.Cr, Chr(255)).Replace(ControlChars.Lf, "").Replace(ControlChars.Tab, "")

        s = s.Replace(";" & Chr(255), ";" & ControlChars.Cr)

        s = s.Replace(Chr(255), " ")

حذف فضاهای خالی اضافي

        ' Eliminate excess whitespace.

        Do

            s = s.Replace("  ", " ")

        Loop Until s.IndexOf("  ") = -1

حذف توضيحات پيش فرض و شناخته شده.

ما در قالبهای خود از سه توضيح استفاده می کنيم که در هر صفحه ای از سايت وارد می شوند.بنا بر اين در زمان خروج ضفحات مط توانيم انها را حذف کنيم.با اين راه توضيحات برای نگهداری و عيب يابی موجودند ولی در زمان انتشار صفحات حذف می شوند.

        ' Eliminate known comments.

        ' We use three comments in our template.  These comments go on every single page on the site.

        ' Obviously, we can kill them when they are going out.  This way, the comments stay in for

        ' maintenance, but are trimmed before release.

        s = s.Replace("<!-- Page Content Goes Above Here -->", "")

        s = s.Replace("<!-- Page Content Goes Below Here -->", "")

        s = s.Replace("<!-- Do not get rid of this &nbsp; on data pages -->", "")

حذف برخی فضاهای خالی وارد شده که از بين بردن آنها مجاز است.به دلايلی يک فضای خالی قبل از هدايت کننده DOCTYPE وارد می شود.

        ' Eliminate some additional whitespace we can kill

        ' For some reason, a single space gets emitted before each of our DOCTYPE directives.

        s = s.Replace(" <!DOCTYPE", "<!DOCTYPE")

اينها فضاهای خالی معمولی هستند که می توانيم حذف کنيم:

        ' These are the most common excess whitespace items we can remove.

        s = s.Replace("<li> ", "<li>").Replace("</td> ", "</td>").Replace("</tr> ", "</tr>").Replace("</ul> ", "</ul>").Replace("</table> ", "</table>").Replace("</li> ", "</li>")

        s = s.Replace("<LI> ", "<LI>").Replace("</TD> ", "</TD>").Replace("</TR> ", "</TR>").Replace("</UL> ", "</UL>").Replace("</TABLE> ", "</TABLE>").Replace("</LI> ", "</LI>")

        s = s.Replace("<td> ", "<td>").Replace("<tr> ", "<tr>")

        s = s.Replace("<TD> ", "<TD>").Replace("<TR> ", "<TR>")

        s = s.Replace("<P> ", "<P>").Replace("<p> ", "<p>")

        s = s.Replace("</P> ", "</P>").Replace("</p> ", "</p>")

        s = s.Replace("style=""display:inline""> ", "style=""display:inline"">")

        s = s.Replace(" <H", "<H").Replace(" <h", "<h").Replace(" </H", "</H").Replace(" </h", "</h")

        s = s.Replace("<UL> ", "<UL>").Replace("<ul> ", "<ul>")

        s = s.Replace(" <TABLE", "<TABLE").Replace(" <table", "<table")

        s = s.Replace(" <li>", "<li>").Replace(" <LI>", "<LI>")

        s = s.Replace(" <br>", "<br>").Replace(" <BR>", "<BR>").Replace("<br> ", "<br>").Replace("<BR> ", "<BR>")

        s = s.Replace(" <ul>", "<ul>").Replace(" <UL>", "<UL>")

جا به جايی Tag های بلند با معادل کوتاه آنها:

        ' Replace long tags with short ones

        s = s.Replace("<STRONG>", "<B>").Replace("<strong>", "<b>")

        s = s.Replace("</STRONG>", "</B>").Replace("</strong>", "</b>")

جا به جايی برخی نمادهای HTML با کدهای کاراکتری درست معادل آنها:

        ' Replace some HTML entities with true character codes

        s = s.Replace("&brkbar;", "|")

        s = s.Replace("&brvbar;", "|")

        s = s.Replace("&shy;", "-")

        s = s.Replace("&nbsp;", Chr(160))

        s = s.Replace("&lsquor;", "'")

        s = s.Replace("&ldquor;", """")

        s = s.Replace("&lsquo;", "'")

        s = s.Replace("&rsquor;", "'")

        s = s.Replace("&rsquo;", "'")

        s = s.Replace("&ldquo;", """")

        s = s.Replace("&rdquor;", """")

        s = s.Replace("&rdquo;", """")

        s = s.Replace("&ndash;", "-")

        s = s.Replace("&endash;", "-")

اگر اين کار را انجام ندهيم JavaScript روی سايت عمل نمی کند:

        ' If we don't do this, JavaScript horks on the site

        s = s.Replace("<!--", "<!--" & ControlChars.Cr)

        s = s.Replace("}", "}" & ControlChars.Cr)

آخرين شانس برای از بين بردن فضاهای خالي:

        ' Last chance to eliminate excess whitespace

        Do

            s = s.Replace("  ", " ")

        Loop Until s.IndexOf("  ") = -1

در نهايت کاری که انجام داده ايم را خارج می کنيم:

        ' Finally, we spit out what we have done.

        Dim outdata() As Byte = System.Text.Encoding.UTF8.GetBytes(s)

        _sink.Write(outdata, 0, outdata.GetLength(0))

    End Sub 'Write

End Class

منبع: http://www.codeproject.com/aspnet/WhitespaceFilter.asp

همه مقالات کليات ASP.NET را ببينيد.
جستجو: بگرد!
جستجوی پيشرفته
نام کاربری |
کلمه عبور |


IranASP.NET - ساخت يک خروجی RSS برای سايت شما

ساخت يک خروجی RSS برای سايت شما

حامد سعیدی فرد | اين مقاله ۴۱۳۵ بار تاکنون ديده شده است.
۱۳۸۳/۵/۱۸ | برای وبلاگ برای وبلاگ
RSS يک راه استاندارد برای به اشتراک گذاشتن محتوای سايت ها با ديگران است. RSS يا همان Really Simple Syndication چيزی نيست به جز يک نشانه گذاری استاندارد شده XML که محتوايی که قصد به اشتراک گذاشتن آن را داريد را توصيف می کند. در اين مقاله قصد داريم چگونگی ساخت يک فايل RSS را در ASP.NET بررسی کنيم.

فرمت RSS

همان طور که قبلا اشاره شد RSS چيزی به جز يک XML نشانه گذاری شده با تگ های مخصوص نيست. کد زير يک نمونه ساده RSS را نشان می دهد.

<rss version="2.0">
<channel xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
<title>IranASP.NET New Articles RSS Feed</title>
<language>fa-IR</language>
<copyright>(c) 2004 by IranASP.NET</copyright>
<pubDate>Sun, 08 Aug 2004 06:11:37 GMT</pubDate>
<lastBuildDate>Sun, 08 Aug 2004 06:11:37 GMT</lastBuildDate>
<generator>IranASP.NET rss generator</generator>
<item>
<title>کاهش حجم خروجی در ASP.NET</title>
<link>http://www.iranasp.net/articles/showarticle.aspx?articleid=154</link>
<pubDate>Sun, 25 Jul 2004 19:30:00 GMT</pubDate>
</item>
</channel>
</rss>

اجازه بدهيد به تگ های اين سند کمی دقيق تر نگاه کنيم

<rss> : تشکيل دهنده تگ ريشه سند است که شامل نسخه سند RSS هم می باشد. آخرين نسخه RSS نسخه 2 است.

<channel> : گره ريشه سند RSS می تواند تگ <channel> هم داشته باشد. اين تگ هم به نوبه خود می تواند شامل گره های <tile>,<link> و <item> باشد.

<title> : مشخص کننده عنوان سند RSS است.

<link> : اين تگ URL سايت ارايه دهنده RSS را مشخص می کند.

<description> : جزييات و اطلاعات بيشتر مربوط به اين سند را مشخص می کند.

<copyright> : اطلاعات مربوط به کپی رايت سند را مشخص می کند.

<generator> : اين تگ Application ای که اين سند را ساخته معرفی می کند.

علاوه بر تگ های بالا، يک سند RSS می تواند يک يا چند تگ <item> داشته باشد. تگ <item> مشخص کننده همان محتوايی است که می خواهيد به اشتراک بگذاريد مثلا يک مقاله يا يکی از پست های يک وبلاگ. هر تگ <item> به علاوه شامل زيرگره های زير است.

<title> : اين تگ عنوان آيتم را مشخص می کند مثلا عنوان مقاله.

<link> : اين تگ URL آن آيتم را نشان می دهد مثلا آدرس مقاله در وب.

<description> : اين تگ آيتم را توصيف می کند، در مورد يک مقاله می تواند شامل خلاصه مقاله باشد.

<pubDate> : اين تگ تاريخ انتشار آن آيتم را نشان می دهد. فرمت معمول برای نمايش اين تاريخ به صورت Sun, 25 Jul 2004 12:00:00 GMT است.

چگونه يک سند RSS بسازيم ؟

حالا که با ساختار يک فايل RSS آشنا شديد، به سراغ دات نت می رويم. چگونه در دات نت يک فايل RSS بسازيم؟ دات نت مجوعه ای غنی ای از کلاس های مرتبط با XML دارد. برای ساختن فايل RSS ما از کلاس XML Text writer استفاده می کنيم. ولی می خواهيم يک راه حل کلی داشته باشيم که با هر وب سايتی کار کند. معنی اين حرف اين است که کد ما بايد مستقل از يک جدول يا يک فيلد خاص در ديتابيس سايت باشد. برای اين کار ما يک کلاس در VS.NET می سازيم. منبع تگ های <item> سند XML ما هم يک ديتاست است که از جدول دلخواه ما در ديتابيس ساخته می شود. کلاسی که قصد نوشتن آن را داريم ويژگی ها (properties) و متدهای (methods) زير را دارد:

ويژگی ها(properties)

Outputstream : يک شی جريان ( Stream ) که خروجی سند در آن نوشته می شود.

RssTitle : مقدار تگ <title> را در زير تگ <channel> مشخص می کند.

PublisherUrl : مقدار تگ <link> را در زير تگ <channel> مشخص می کند.

Description : مقدار تگ <description> را در تگ <channel> مشخص می کند.

Copyright : مقدار تگ <copyright> را در زير تگ <channel> مشخص می کند.

Generator : مقدار تگ <generator> را در زير تگ <channel> مشخص می کند.

ItemSource : تعيين کننده شی ديتاستی است که سطرهای آيتم را شامل می شود.

ItemTitleField : نام Datacolumn ( ستون داده ای در ديتاست ) که مقدار تگ <title> از تگ <item> را نشان می دهد.

ItemURLField : نام Datacolumn که مقدار تگ <link> از تگ <item> را مشخص می کند.

ItemDescriptionField : نام Datacolumn که مقدار تگ <description> از تگ <item> را معرفی می کند.

ItemPublicationDateField : نام Datacolumn که مقدار تگ <pubDate> از تگ <item> را نشان می دهد.

متدها

PublishRss : اين متد سند نشانه گذاری شده RSS را در Outputstream می نويسد.

در زير کد کامل کلاس RSS را می بينيد، توجه کنيد که برای سادگی و نمايش سريع به جای properties از متغيرهای عمومی ( Public ) استفاده شده است.

Public Class Rss
Public OutputStream As Stream
Public RssTitle As String
Public PublisherUrl As String
Public Description As String
Public Copyright As String
Public Generator As String
Public ItemSource As DataSet
Public ItemTitleField As String
Public ItemUrlField As String
Public ItemDescriptionField As String
Public ItemPublicationDateField As String
Public Shared Function PublishRss(ByVal r As Rss)
Dim writer As New XmlTextWriter(r.OutputStream,
System.Text.Encoding.ASCII)
writer.WriteStartElement("rss")
writer.WriteAttributeString("version", "2.0")
writer.WriteStartElement("channel")
writer.WriteElementString("title", r.RssTitle)
writer.WriteElementString("link", r.PublisherUrl)
writer.WriteElementString("description", r.Description)
writer.WriteElementString("copyright", r.Copyright)
writer.WriteElementString("generator", r.Generator
For Each row As DataRow In r.ItemSource.Tables(0).Rows
writer.WriteStartElement("item")
writer.WriteElementString("title", row(r.ItemTitleField))
writer.WriteElementString("link", row(r.ItemUrlField))
writer.WriteElementString("description",
row(r.ItemDescriptionField))
writer.WriteElementString("pubDate",
CType(row(r.ItemPublicationDateField),
DateTime).ToString("ddd, dd MMM yyyy 12:00:00 tt G\MT"))
writer.WriteEndElement()
Next
writer.WriteEndElement()
writer.WriteEndElement()
writer.Flush()
End Function
End Class

در کد کلاس بالا متد PublishRss مهمترين اتفاقی است که در کلاس می افتد. ابتدا ما يک نمونه از کلاس System.XML.XmlTextwriter ساخته ايم. اين کلاس سريع ترين راه برای نوشتن اسناد XML است. بعد OutputStream را به تابع پاس کرده و encoding سند را مشخص کرديم. در مورد اين کد از ASCII استفاده شده است. بعد از اين شروع به نوشتن بخش های مختلف سند RSS خودمان کرديم. در کلاسXmlTextwriter ما از متدهای زير برای نوشتن سند خودمون استفاده کرديم:

WritestartElement : اين متد تگ شروع را برای يک تگ خاص می نويسد (هر تگ شامل يک تگ شروع هست و يک تگ پايان مثلا <channel> تگ شروع و <channel/> تگ پايان می باشد) .

WriteAttributeString : خواص تگ باز فعلی را می نويسد.

WriteElementString : مقدار هر تگ که بين تگ شروع و تگ پايان قرار دارد را می نويسد.

WriteEndElement : تگ پايان را برای تگی که اخيرا باز بوده می نويسد. نيازی نيست که تگ های داخلی تر را مشخص کنيد.

Flush : اين متد، تمام خروجی های بافرشده را به مقصد منتقل می کند.

توجه کنيد که شما بايد متدهای WriteStartElement و WriteEndElement را برای بهتر شکل دادن به سند خودتان استفده کنيد.

ساختن وب فرم ASP.NET

حالا که يک کلاس کلی نوشتيم، می تونيم از اين کلاس در وب فرم خودمان استفاده کنيم. يک ساختار که به عنوان نمونه می توانيد در بانک اطلاعاتی از آن استفاده کنيد به شکل زير می باشد. از اطلاعات اين ساختار در بانک اطلاعاتی برای ساخت سند RSS استفاده می گردد.

Article_ title - Varchar (255)
Article_ Description -Varchar (1000)
Article_ url - Varchar (255)
Article_ pubdate - DateTime

ما به کمک يک تابع به نام GetDataSet اطلاعات را به ديتاست می دهيم، اين ديتاست به عنوان منبع برای توليد فايل RSS مورد استفاده قرار می گيرد. برای پر کردن ديتاست از يک DataAdapter استفاده می کنيم :

Function GetDataSet() as DataSet
Dim cnn as New SqlConnection("connection string here")
sql = "select * from sometable order by Article_pubdate desc"
Dim da As New SqlDataAdapter(sql,cnn)
Dim ds as New DataSet()
da.Fill(ds,"MyArticles")
Return ds
End Function

برای ايجاد يک خروجی RSS از محتوای سايت، بايد يک نمونه از کلاس Rss که نوشتيم بسازيم، سپس ويژگی های مختلف آن را مقداردهی کنيم و سپس متد GetDataSet را فراخوانی کنيم. بعد از اينکه ديتاست را بدست آورديم فقط کافی است که خصوصيت ItemSource شئ گرفته شده از کلاس Rss را به همين ديتاست مقدار دهيم. به علاوه دو خصوصيت از شئ response يعنی ContentEncoding و ContentType را هم مقدار می دهيم.

Private Sub Page_Load(ByVal sender As System.Object,
ByVal e As System.EventArgs) Handles MyBase.Load
Dim r As New Rss
Dim ds As DataSet = GetDataSet()
r.OutputStream = Response.OutputStream
r.RssTitle = "DotNetBips.com Latest Articles"
r.PublisherUrl = Request.Url.Host
r.Description = "DotNetBips.com - Applying.NET"
r.Copyright = "Copyright (C) DotNetBips.com."
r.Generator = "DotNetBips.com RSS Generator"
r.ItemSource = ds
r.ItemTitleField = "Article_title"
r.ItemDescriptionField = "Article_Description"
r.ItemPublicationDateField = "Article_pubdate"
r.ItemUrlField = "Article_url"
Response.ContentEncoding = System.Text.Encoding.UTF8
Response.ContentType = "text/xml"
Rss.PublishRss(r)
Response.End()
End Sub

حالا تابع PublishRss را فراخوانی می کنيم و شئ گرفته شده از کلاس Rss را به اين تابع پاس می کنيم. تمام شد! حالا يک خروجی XML بر اساس استاندارد RSS داريم.

مبنع: http://www.dotnetbips.com

همه مقالات کليات ASP.NET را ببينيد.
جستجو: بگرد!
جستجوی پيشرفته
نام کاربری |
کلمه عبور |


IranASP.NET - ايجاد يک کنترل - قسمت اول

ايجاد يک کنترل - قسمت اول

رضا قلعه | اين مقاله ۲۷۵۶ بار تاکنون ديده شده است.
۱۳۸۳/۵/۲۷ | برای وبلاگ برای وبلاگ
کنترل يک عنصر ويژوال می باشد که می توان آنرا در زمان طراحی برروی فرم قرار داد و در صورت لزوم خاصيت های آن را تغيير داد. اين مقاله به بررسی چگونگی ساخت يک کنترل برای WinForm می پردازد که با اندکی تغييرات می تواند عينا برای فرم های وب نيز مورد استفاده قرار گيرد.

کنترل يک عنصر ويژوال می باشد که می توان آنرا در زمان طراحی برروی فرم قرار داد و در صورت لزوم خاصيت های آنرا تغيير داد. در اين قسمت استانداردهای لازم برای ايجاد يک کنترل و روش های آن شرح داده می شود.

ايجاد يک پروژه
بمنظور ايجاد يک کنترل جديد شما نيازمند ايجاد يک پروژه می باشيد. در اين حالت شما دارای دو انتخاب می باشيد: Windows Control Library و Web Control Library. بسته به نوع کنترلی که می خواهيد طراحی کنيد يکی از موارد فوق را انتخاب نماييد. پس از ايجاد پروژه می توانيد در صورت لزوم فايل کنترل ايجاد شده (UserControl1.cs) را پاک کرده و يک کلاس جديد به پروژه اضافه نماييد.

ارث بری از کنترل موجود

برای ايجاد يک کنترل جديد می توانيد در صورت لزوم از کنترلهای موجود ارث بری کرده و آنها را بر حسب نياز تغيير دهيد و يا يک کنترل را از ابتدا ايجاد نماييد.

public class ControlName : System.Windows.Froms.Panel
{
...

افزودن خصوصيت (Property)

بمنظور ايجاد خصوصيت جديد شما نيازمند تعريف يک متغيير خصوصی و يک تابع عمومی برای مقداردهی و اخذ مقدار خصوصيت می باشيد.

private System.Windows.Forms.Border3DSide borderSide;

public System.Windows.Forms.Border3DSide BorderSide
{
get { return this.borderSide; }
set
{
if ( this.borderSide != value )
{
this.borderSide = value;
this.Invalidate(); // force repaint control at design time
}
}
}

پس از تعريف خصوصيت جديد ترجيحا آنرا در سازنده کلاس مقداردهی اوليه نماييد.

public ControlName
{
this.borderSide = System.Windows.Froms.Boder3DSide.All;
this.border3DStyle = System.Windows.Froms.Border3DStyle.Etched;
}

بازنويسی متدهای ارث برده شده (override)
در صورتيکه کنترل ايجاد شده را از يک کنترل موجود ارث برده باشيد، ممکن است نيازمند بازنويسی کد تعدادی از متدهای کنترل اوليه باشيد.

protected override void OnPaint(System.Windows.From.PaintEventArgs e)
{
base.OnPaint(e);

System.Windows.Froms.ControlPaint.DrawBorder3D (
e.Graphics,
this.ClientRectangle,
this.border3DStyle,
this.borderSide );
}

بمنظور پيدا کردن تمامی متدهای موجود کلاس ارث برده شده می توان از Object Browse استفاده نمود و پس از پيدا کردن متد مورد نظر روی آن کليک راست کرده و Override را از گزينه Add انتخاب نماييد.

افزودن صفات مربوط به خصوصيت ها به منظور نمايش آن در محيط طراحی
بمنظور نمايش صحيح خصوصيت های نوشته شده در پنجره Properties محيط طراحی بايد چندين صفت مربوط به خصوصيت را تنظيم نمود.

Bindable: با دادن مقدار true به عنوان پارامتر به اين تابع پس از هر بار تغيير اين خصوصيت، در محيط طراحی سيگنالی به معنی اينکه مقدار اين خصوصيت تغيير کرده صادر می گردد و کلاس designer شما (در ادامه توضيح داده خواهد شد) را آگاه خواهد کرد.

DefualtValue: با دادن مقدار پيش فرض مورد نظر برای اين خصوصيت در محيط طراحی مقدار ذکر شده به عنوان پيش فرض نمايان می گردد.

Category: با دادن يک رشته به عنوان پارامتر به اين تابع دسته قرار گرفتن خصوصيت در پنجره Properties محيط طراحی مشخص می گردد.

Description: با دادن يک رشته به عنوان پارامتر به اين تابع در صورت انتخاب خصوصيت در ليست Properties، توصيف مشخص شده در پايين اين پنجره نمايش داده خواهد شد.

ReadOnly: با true قرار دادن پارامتر اين متد خصوصيت مورد نظر در محيط طراحی بصورت فقط خواندنی نمايش داده می شود.

Editor: اين تابع دو پارامتر می گيرد. اولين پارامتر مشخص کننده نوع Editor و پارامتر دوم مشخص کننده نوع پايه Editor می باشد (در ادامه توضيح داده خواهد شد).

[Bindable(true), Category("Border Options"),
DefaultValue(System.Windows.Forms.Border3DSide.All),
Description("Specifies the sides of the panel to
apply a three-dimensional border to.")]
public System.Windows.Forms.Border3DSide BorderSide
{
...

قسمت دوم

همه مقالات فرم های وب را ببينيد.
جستجو: بگرد!
جستجوی پيشرفته
نام کاربری |
کلمه عبور |


IranASP.NET - ايجاد يک کنترل - قسمت دوم

ايجاد يک کنترل - قسمت دوم

رضا قلعه | اين مقاله ۲۵۴۰ بار تاکنون ديده شده است.
۱۳۸۳/۶/۳ | برای وبلاگ برای وبلاگ
کنترل يک عنصر ويژوال می باشد که می توان آنرا در زمان طراحی برروی فرم قرار داد و در صورت لزوم خاصيت های آن را تغيير داد. اين مقاله به بررسی چگونگی ساخت يک کنترل برای WinForm می پردازد که با اندکی تغييرات می تواند عينا برای فرم های وب نيز مورد استفاده قرار گيرد.

قسمت اول

ايجاد يک ويرايشگر برای تعيين مقدار خصوصيت در محيط طراحی
بمنظور ايجاد يک ويرايشگر برای يک خصوصيت شما ابتدا بايد فرم مورد نظر را طراحی کنيد. البته لازم به ذکر می باشد که حتما لازم نيست فرم جديدی طراحی کنيد و می توانيد از فرم ها و مدلهای موجود استفاده کنيد. در اينجا فرض کنيد که يک فرم در شاخه Design کنترل مورد نظر ايجاد کرده ايد. پس از طراحی و ايجاد فرم مورد نظر بايد يک کلاس ارث برده شده از UITypeEditor ايجاد کرده و فرم مورد نظر را فراخوانی نماييد. در اين کلاس بايد حداقل دو متد EditValue و GetEditStyle را بازنويسی مجدد نماييد. متد EditValue زمانيکه کاربر برروی دکمه کنار خصوصيت کليک کند فراخوانی می گردد. در اين متد می توانيد فرم ايجاد شده را فراخوانی کنيد. متد دوم به منظور تعيين حالت نمايش فرم ايجاد شده بکار می رود.

public class StringEditor : System.Drawing.Design.UITypeEditor
{
public override object EditValue(ITypeDescriptorContext context,
IServiceProvider serviceProvider, object value)
{
if ((context != null) && (serviceProvider != null))
{
//Set the editor service
IWindowsFormsEditorService edSvc =
(IWindowsFormsEditorService)serviceProvider.GetService(
typeof(IWindowsFormsEditorService));

if (edSvc != null)
{
//Create new designed form
DesignedForm form = new DesignedForm();
form.Value = (string)value;
//Show form as a dialog
DialogResult result = edSvc.ShowDialog(form);
if (result == DialogResult.OK)
{
value = form.Value;
}
}
}
return value;
}

public override UITypeEditorEditStyle GetEditStyle( ITypeDescriptorContext context)
{
if (context != null) {
//The editor will be a modal window.
return UITypeEditorEditStyle.Modal;
}
return base.GetEditStyle(context);
}
}

پس از انجام تعاريف فوق بايد صفت Editor خصوصيت را همانطور که در قسمت قبلی ذکر شد مقدار دهی نماييد.

[Editor(typeof(StringEditor),
typeof(UITypeEditor))]
public string ServerUrl
{
...

در صورتيکه نوع خصوصيت شما از نوع enum باشد در محيط طراحی بصورت خودکار ليستی از مقادير قابل انتخاب تعريف شده در enum در اختيار کاربر قرار می گيرد. در صورتيکه خواسته باشيد خود مقادير ليست را مشخص کرده و يا نوع خصوصيت از enum نبوده ولی نيازمند ليستی از مقادير در زمان طراحی باشيد می توانيد کلاسی از ListboxTypeEditor ارث بری کرده و با بازنويسی متد FillInList آن مقادير مورد نظر خود را در ليست درج نماييد. طريقه استفاده آن در خصوصيت همانند مورد فوق می باشد.

public class FormatListboxTypeEditor : ListboxTypeEditor
{
protected override void FillInList(ITypeDescriptorContext context,
IServiceProvider provider, ListBox listBox)
{
listBox.Items.Add("Item 1");
listBox.Items.Add("Item 2");
listBox.Items.Add("Item 3");
listBox.BorderStyle = BorderStyle.None;
}
}

افزودن امکان پشتيبانی توسط جعبه ابزار (ToolBox)
افزودن امکان پشتيبانی توسط جعبه ابزار برای يک کنترل بسيار آسان می باشد. بدين منظور نيازمند يک تصوير برای نمايش در جعبه ابزار و چندين تنظيم کوچک برروی کلاس می باشيم.

تصوير مورد استفاده برای کنترل از نوع Bitmap بوده و بايد 16 رنگ بوده و اندازه آن 16*16 باشد. خصوصيت Build Action تصوير نيز بايد برابر Embedded Resource قرار گيرد. مرحله نهايی در اين قسمت تنظيم صفات ToolboxItem و ToolboxBitmap می باشد.

[ToolboxItem(true)]
[ToolboxBitmap(typeof(ImageName))]
public class DividerPanel : System.Windows.Forms.Panel
{
...

افزودن کلاس Designer
از اين کلاس بمنظور انجام تنظيمات مورد نظر و اعمال آن در محيط طراحی استفاده می شود. بدين منظور يک کلاس ايجاد نموده و مطابق کد زير آنرا اصلاح نماييد.

public class ControlNameDesigner :
System.Windows.Forms.Design.ScrollableControlDesigner
{
}

به عنوان مثال در صورتيکه نياز داشته باشيد يک خصوصيت خاص کلاس در محيط طراحی ظاهر نشود می توانيد متد PreFilterProperties را باز نويسی مجدد کرده و خصوصيت مورد نظر را در محيط طراحی حذف نماييد.

protected override void PreFilterProperties(
System.Collections.IDictionary properties)
{
properties.Remove("BorderStyle");
}

در انتها با مشخص کردن صفت DesignerAttribute کلاس کنترل، کلاس Designer ايجاد شد را به کنترل معرفی نماييد.

[DesignerAttribute(typeof(ClassNameDesigner))]
public class ControlName : System.Windows.Forms.Panel
{
...

صفات Assembly و امضا
آخرین قدم در راه ایجاد یک کنترل فراهم کردن اطلاعات لازم برای assembly می باشد. این مرحله اجباری نمی باشد ولی بسیار تاکید می شود که این مرحله را نیز انجام دهید. در ابتدا فایل AssemblyInfo.cs را باز کرده و اطلاعات لازم را در آن وارد نمایید.

[assembly: AssemblyTitle("Control Title")]
[assembly: AssemblyDescription("Control Description")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyCompany("Company")]
[assembly: AssemblyProduct("Product Name")]
[assembly: AssemblyCopyright("Copyright Info")]
[assembly: AssemblyTrademark("")]
[assembly: AssemblyCulture("")]

در ادامه چندین صفت که بطور پیش فرض در این فایل موجود نمی باشد را بصورت زیر به این فایل اضافه نمایید.

// Flagging your assembly with the CLS Compliant attribute
// lets the Framework know that it will work with all
// CLS Compliant languages, and theoretically with all
// future framework platforms (such as Mono on Linux).
// If possible you should avoid using any non-CLS compliant code
// in your controls such as unsigned integers (uint) and
// calls to non-framework assemblies.
[assembly: System.CLSCompliant(true)]

// The ComVisible attribute should always be explicitly set for controls.
// Note that in order for your control to be consumed by
// COM callers, you must use parameter-less constructors
// and you cannot use static methods.
[assembly: System.Runtime.InteropServices.ComVisible(true)]

آخرین مرحله قبل از استفاده از کنترل امضاء نمودن assembly می باشد. امضاء کردن assembly بمنظور جلوگیری از دستکاری و خراب شدن هنگام بارگذاری و یا خراب شدن در اثر download مؤثر می باشد. در ابتدا شما باید با استفاده از ابزار Strong Name که در محیط Command Prompt، محیط Visual Studio.NET می وجود می باشد بمنظور ایجاد یک کلید عمومی/خصوصی برای assembly بصورت زیر استفاده نمایید.

sn -k [outputfile].snk

فایل ایجاد شده را در شاخه پروژه خود کپی کرده و عبارت زیر را در فایل assembly وارد نمایید.

[assembly: AssemblyKeyFile("..\\..\\..\\outputfile.snk")]

همه مقالات فرم های وب را ببينيد.
جستجو: بگرد!
جستجوی پيشرفته
نام کاربری |
کلمه عبور |


IranASP.NET - کوچ از ASP.NET 1.x به ASP.NET 2.0 - قسمت اول

کوچ از ASP.NET 1.x به ASP.NET 2.0 - قسمت اول

کيوان نيّری | اين مقاله ۴۰۹۳ بار تاکنون ديده شده است.
۱۳۸۳/۶/۱۱ | برای وبلاگ برای وبلاگ
نسل اول ASP.NET در قالب نسخه‎های 1.0 و 1.1 ارائه گشت. گذشت زمان و کسب تجربيات متعدد، پيدايش نيازهای جديد، ضعف های موجود و نيز به دليل ايجاد راه حل‎های تکراری ولی پرکاربرد توسط برنامه نويسان جهت حل برخی مسائل که همواره وقت زيادی را از آنها می گرفت، همگی سبب شدند تا مايکروسافت به فکر گسترش تکنولوژی NET. و ASP.NET به عنوان جزء مهمی از آن باشد. حاصل کار پيدايش نسخه بهتر شده دات نت و مهمتر از آن ASP.NET 2.0 جهت ارائه در سال 2005 بود.

مقدمه
زبانهای کامپيوتری و چارچوبهای کاری با توجه به نيازهای روز طراحان سيستمهای نرم افزاری روز به روز تغييير کرده و گسترده تر می شوند. ASP.NET مهمترين راه حل مايکروسافت برای طراحان صفحات پويای وب نيز از اين قاعده مستثنی نيست. اين قابليت مهم تکنولوژی NET. که به اعتقاد بسياری از طراحان و کارشناسان بهترين در نوع خودش می باشد هر روز به منبعی کارآمد تر برای ساخت سايتهای بزرگ تبديل می شود.

بعد از نسخه اوّل و دوم ASP.NET در نسخه های 1.0 و 1.1 در سالهای 2002 و 2003 که تفاوت چندانی با هم نداشتند نيازهای جديد، ضعف های گذشته و راه حل های متداول که همواره وقت زيادی را از طراحان می گرفت باعث شد مايکروسافت به فکر گسترش تکنولوژی NET. و ASP.NET به عنوان جزء مهمی از آن باشد. نتيجه مجموعه‎ی Visual Studio .NET Whidbey بود که در سال 2004 به بازار آمد.

اين نسخه تفاوتهای اساسی و زيادی با نسخه های قبلی دارد که با به بازار آمدن اين نسخه لازم است طراحان به فکر يادگيری قابليت ها و خصوصيات جديد باشند لذا بر آن شدم تا اين مقاله را برای ساده شدن راه طراحان ايرانی به رشته تحرير در آورم. به قولی که حضرت مولانا می فرمايد:

وقت آن شد که به زنجير تو ديوانه شويم (جناب بيل گيتس)
بند را بر گسليم از همه بيگانه شويم!!!

البته مفهوم اين شعر چيز ديگری است!! ولی تمامی علاقه مندان و طراحان برای رشد سريع تر اين تکنولوژی در ايران بايد آن را زودتر فرا گيرند.

اين مقاله بر اساس موضوع بندی و شيوه نگارش مقاله ای ديگر با همين عنوان در MSDN به طور خلاصه ولی با حفظ تمام مفهوم و در جهت ساده سازی با استفاده از کدهای مثال در مقاله اصلی نگاشته شده است.

اهداف ASP.NET 2.0
طراحان از ساخت ASP.NET 2.0 چهار هدف اصلی را دنبال می کردند:

۱- افزايش اعتبار و کاربردی بودن برنامه های تحت Web

در گذشته بيشتر برنامه های کاربردی تحت وب روی Microsoft Information Services (IIS) 5.0 اجرا می شدند. ASP.NET 2.0 بر اساس IIS 6.0 ساخته شده است که مدل پردازشی جديدی را برای برنامه های کاربردی ايجاد می کند. مهمترين خصوصيت جديد آن اين است که هر برنامه کاربردی در پروسه منفرد مخصوص به خود پردازش شده و نمی تواند برنامه های کاربردی ديگر را تحت تاثير قرار دهد. ساده تر اينکه برنامه های کاربردی نمی توانند برنامه های ديگر را مختل کنند. هر برنامه به طور کامل جدا از بقيه اجرا می شود. پس اگر يک برنامه مختل شد بقيه تاثير نمی پذيرند.

۲- کاهش خطوط کد لازم برای اعمال متداول

ASP.NET 2.0 شامل Wizard ها و کنترلهايی است که به شما در طراحی اعمال متداول کمک می کنند (برای مثال دسترسی به داده ها)

۳- خصوصيات جديد کاربری برای شخصی سازی برنامه های کاربردی Web

ASP.NET 2.0 شامل کنترلهای ساخته شده برای کمک به مديريت Account کاربران و شخصی سازی محتوا و لايه بندی برنامه های کاربردی است. سرويس عضو گيری به شما در مديريت کاربران کمک می کند. کنترلهای جديد Login به همراه سرويس عضو گيری ساخته شده اند تا ايجاد Account و Login کاربران را بدون نياز به هيچ کدی خودکار سازی کنند.

۴- افزايش خصوصيات طراحی برای عمومی تر کردن ظاهر برنامه ها و لايه های آنها

ASP.NET 2.0 شامل Master Pageها، Themeها و Skinها برای ساخت برنامه های کاربردی بزرگ وب با يک فرم طراحی ثابت برای صفحات است.

در ادامه به مرور جزئی تر اين اهداف و نحوه پياده سازی آنها می پردازيم.

کوچ از ASP.NET 1.x
اگر شما برنامه کاربردی در حال ساخت با نسخه ASP.NET 1.x داريد هيچ نگران نباشيد چون ASP.NET 2.0 به طور کامل با ASP.NET 1.x هماهنگ است. اين به اين معنا است که برنامه های کاربردی ASP.NET 1.x بدون هيچ مشکلی روی ASP.NET 2.0 اجرا می شوند ولی خواهيد ديد که لازم است برای بهتر شدن برنامه های کاربردی خود آنها را بروز کنيد به طور کلی مدل گسترش ASP.NET 2.0 تغيير کرده است.

تغييرات در معماری
اساس معماری ASP.NET هميشه بر انعطاف و توسعه پذيری استوار بوده است. ASP.NET 2.0 نيز اين روش را با مدل های Provider جديد که پشتيبان کننده خصوصيات جديد هستند دنبال کرده است. Utilityها و APIهای جديد برای گسترش کارايی و تنظميات سايت ها اضافه شده اند. تمام اينها برای افزايش سرعت و سادگی در گسترش برنامه های کاربردی ASP.NET 2.0 طراحی شده اند.

مدل Provider
بسياری از خصوصيات جديد در ASP.NET 2.0 بر مبنای ارتباط بين برنامه کاربردی تحت Web و منبع داده ای قرار گرفته اند بنابراين برای دسترسی به اين هدف ASP.NET 2.0 از مجموعه ای از تامين کنندگان استفاده می کند.

مدل Provider در واقع ابزاری است که به گسترش دهندگان در چارچوب ASP.NET 2.0 برای رسيدن به منابع داده و رفع نيازهای لازم برای نيل به اين هدف طراحی شده است. برای مثال طراح می تواند برای سيستم ذخيره اطلاعات مشخصات از يک منبع داده استفاده کند. بيشتر تامين کنندگان برای کار با بانکهای اطلاعاتی در سيستمها طراحی شده اند پس برنامه نويس مختار است که Methodها و کلاسهای لازم برای هر تامين کننده را انتخاب کند:

ASP.NET 2.0 Providers
مدل Provider مجموعه ای از محيط های کاربری را تعريف می کند و به منابع داده ای لازم برای فرامين خاص مرتبط می سازد. ASP.NET از Providerهای گسترده و گوناگونی استفاده می کند که بعضی از مشهورترين و مهمترين آنها عبارتند از:

Membership: اين سيستم عضويت تعيين اعتبار و مديريت کاربران را پشتيبانی می کند.
Profile: اعمال مربوط به اطلاعات کاربری مخصوص به هر Profile را پشتيانی می کند.
Personalization: اين Provider تامين کننده تنظيمات هر بخش شبکه و لايه های مخصوص هر کابر را پشتيبانی می کند.
Site Navigation: اين Provider نقشه فيزيکی محل ذخيره صفحات ASP.NET را تامين می کند و برای تعيين انواع تغييرات در لينک های مورد استفاده در کنترلهای به کار رفته در صفحات به کار می رود.
Data Provider: ابزار ADO.NET هميشه از اين مدل Provider برای ارتباط بين يک Database (بانک اطلاعاتی) و API خود استفاده کرده است. ASP.NET 2.0 نيز مانند گذشته از اين قابليت مهم تکنولوژی NET. بهره می گيرد و در اين راه از خصوصيات جديد و پيش فرض در ADO.NET استفاده می کند.

هر يک از اين Providerها به طور مستقل از سايرين عمل می کنند پس شما می توانيد Provider مخصوص Profile را با Profile مخصوص Membership بدون هيچ مشکلی جا به جا کنيد. در ادامه اين مقاله مثال های خاصی در مورد چگونگی استفاده از اين تامين کنندگان در بخش های مختلف ASP.NET 2.0 خواهيد ديد.

مدل کد نويسی ASP.NET 2.0
در ASP.NET 1.x شما می توانيد يک صفحه ASP.NET را به دو شيوه طراحی کنيد: اولين راه نوشتن مستقيم خطوط کد در بين کدهای HTML (اصطلاحا Code Inline) و دومين راه نوشتن کدهای برنامه به صورت جداگانه Code Behind بود. تکنيک دوم تکنيکی جديد و مهم بود چرا که در روش اوّل که از گذشته مورد استفاده بوده کدهای برنامه نويسی با کدهای HTML در کنار يکديگر باعث ناخوانايی و مشکل در تغييرات چه در ظاهر و چه در متن کدهای برنامه بودند.

مدل Code Behind يک کلاس خارجی برای نگهداری کدها ايجاد می کرد در حاليکه ASPX کدهای HTML و Tag های آنرا نگهداری می کرد. اين تکنيک کدها را از محتوا جدا می کرد ولی مشکلات ديگری را ايجاد می کرد و آن هم نياز برنامه نويس به نگهداری دو فايل مجزا برای هر صفحه بود. ASP.NET 2.0 هنوز هر دوی اين مدلها را با تغييراتی نسبتا اساسی پشتيبانی می کند.

Code Inline
اين مدل کد نويسی حالا مدل اصلی و پيش فرض برای Visual Studio 2005 است و جای مدل Code Behind را گرفته، هر کدی که شما به صفحه اضافه کنيد به طور خودکار به بلاک <Script> در فايل ASPX به جای کلاس Code Behind اضافه می شود. Visual Studio 2005 هنوز کد را در حالت نمايش مخصوص خود نشان می دهد به عبارتی ديگر شما در استفاده از Visual Studio تغييری نمی دهيد به جز اينکه کدهای شما به طور خودکار و مستقيم داخل صفحه ASPX به جای کلاسی مجزا وارد می شود.

نکته قابل توجه اين است که هنوز کدها از محتوا از طريق بلاکهای <Script> جدا هستند ولی در يک فايل قرار می گيرند. پس شما به عنوان يک برنامه نويس نبايد نگران دو فايل باشيد و فقط با يک فايل در گير هستيد.

Code Behind
اگر شما می خواهيد با يک فايل کد جدا گانه کار کنيد لازم است شما در زمان ايجاد يک صفحه ASPX اين کار را انجام دهيد خوشبختانه اين کار به سادگی کليک رو يک Check Box در زمان ايجاد فايل صفحه است.

تفاوت اساسی بين Code Behind در ASP.NET 1.x و ASP.NET 2.0 اين است که فايل Code Behind اکنون به عنوان Partial Class به جای يک Class کامل محسوب می شود. يک Partial Class يک ساختار جديد NET. است که به شما اجازه می دهد يک کلاس منفرد را در فايلهای منبع مختلف استفاده کنيد. در ASP.NET 2.0 يک Partial Class کاملا برای فايلهای Code Behind مناسب است به گونه ای که از روابط Inherit که در مدل قبلی Code Behind استفاده می شد بی نياز است.

دو Partial Class يعنی Code Behind و ASPX در زمان Compile شدن به درون يک کلاس منفرد فراخوانی می شوند، آنگاه فايل Code Behind از تمام تعاريف کنترلها و فراخوانيهايی که با مدل قبلی Code Behind به اشتراک گذاشته شده اند مجزا است. مهمترين تفاوت اساسی قابل مشاهده در فايل Code Behind اين است که ديگر شامل تمام کدهای خودکار و عمومی اضافه شده به هر صفحه برای مشخص کردن ارتباطات، منابع و کنترلها نيست. يک فايل Code Behind قديمی شامل ناحيه Initialization برای تعريف هر کنترل قرار داده شده در هر صفحه است:

public class WebForm1 : System.Web.UI.Page
{
protected System.Web.UI.WebControls.Label Label1;
private void Page_Load(object sender, System.EventArgs e) { }
#region Web Form Designer generated code
override protected void OnInit(EventArgs e)
{
InitializeComponent();
base.OnInit(e);
}
private void InitializeComponent()
{
this.Load += new System.EventHandler(this.Page_Load);
}
#endregion
void Page_Load(object sender, EventArgs e)
{
Label1.Text = "Hello ASP.NET 2.0";
}
}

از زمانی که تعاريف کنترلها به صفحه ASPX وارد شده اند فايل جديد تمام اين کدها را حذف کرده است:

namespace ASP {
public partial class Webform1_aspx
{
void Page_Load(object sender, EventArgs e)
{
Label1.Text = "Hello ASP.NET 2.0";
}
}
}

می توانيد ببينيد که فايل Code Behind جديد ساده تر است. فايل Code Behind به طور خودکار به تمام کنترلهای اضافه شده به هر صفحه ASP.NET دسترسی دارد.

Code directory/
آخرين تغيير بزرگ در مدل کدنويسی دسترسی مستقيم به يک مساله در ASP.NET است. بيشتر برنامه های کاربردی تحت Web به يک يا چند کلاس پشتيبانی کننده نياز دارند. متد قبلی ايجاد يک پروژه جداگانه برای هر کلاس و اضافه کردن يک Reference به پروژه پشتيبانی کننده از درون برنامه کاربردی تحت Web بود.

حتی اگر شما پروژه جديد ايجاد نمی کرديد لازم بود يک Reference به فضای نام (Name Space) مورد استفاده در برنامه های خود ايجاد کنيد. نگهداری چند پروژه جداگانه برنامه ها را مشکل تر و بزرگتر می کردند که معمولا برای طراحانی که از يک يا دو کلاس ساده استفاده می کردند مناسب نبود.

ASP.NET 2.0 روش جديدی را با اضافه کردن کدهای پشتيبانی ارائه کرده است و آن يک Directory جديد با نام Code/ است که به طور خودکار به برنامه های کاربردی اضافه می شود و به عنوان يک منبع توسط برنامه کاربردی ASP.NET شناخته می شود. اين به اين معنی است که هر کلاسی که داخل اين Directory اضافه شود به طور خودکار توسط صفحات ASPX در برنامه های کاربردی شما قابل دسترسی هستند.

کامپايلر Visual Studio .NET 2005 و ASP.NET به طور خودکار اسمبلی های لازم را از اين کلاسها ايجاد می کنند و آنها را در اسمبلی های برنامه های کاربردی تحت وب شما قرار می دهند.

تنظيمات و نگهداری سايت
يکی از مشکلات بزرگ طراحان ASP.NET در گذشته، تنظيم مشخصات المانهای فايل Web.Config بود که متنوع و Case Sensitive بودند در ASP.NET 2.0 و Visual Studio .NET 2005 شما خصوصيات جديدی داريد که در اجرای فرامين شما را ياری می دهند.

Intellisense در Web.Config
متاسفانه معادل فارسی مناسبی برای Intellisense به ذهنم نرسيد. ولی اين قابليت مهم زبانهای Visual همان پنجره ای است که خصوصيات و متدهای اشيا مختلف را در زمان تايپ کدها به نمايش می گذارد.

اول از همه خصوصيت جديد و مهم Intellisense اين است که برای هر فايل XML که دارای فرم تعريف شده ای است عمل می کند. برای فايل Web.Config اين به آن معناست که شما کمک کامل Intellisense را برای ويرايش اين فايل از طريق Visual Studio در اختيار داريد.

Intellisense برای کاهش شانس تنظيمات اشتباه در فايل کمک زيادی به شما می کند. از طرفی ASP.NET 2.0 همچنين شامل يک Administrative Web site و کنسول مديريتی مايکروسافت است که کارها را آسانتر می کند.

Administrative Web site
برای پياده سازی پروسه مديريت کاربران، ASP.NET 2.0 يک ابزار تنظميات وب سايت در اختيار شما می گذارد اين ابزار يک وب سايت ساده است که تنها از طريق يک ارتباط امن يا يه طور مستقيم از Local host قابل دسترسی است به وسيله اين ابزار يک Administrator می تواند يک برنامه کاربردی را با تنظيم خدماتی مثل مديريت کاربر، امنيت و Profileها مديريت کند. اين ابزار همچنين اجازه می دهد که به سادگی شمارنده ها، خطايابی و Trace کردن اطلاعات برای برنامه را تنظيم کنيد.

کنسول مديريتی مايکروسافت
ASP.NET 2.0 يک کنسول مديريتی مايکروسافت (MMC) برای IIS ارائه می کند که به شما کمک می کند تصميم بگيريد برنامه ها بايد با چه نسخه ای از NET. Framework اجرا شوند.

همچنين MMC IIS به شما کمک می کند نسخه ای که برنامه کاربردی شما در ASP.NET از آن استفاده می کند را مشخص کنيد و محل فايل Web.Config را نشان می دهد. همچنين اين کنسول دارای يک Botton مخصوص Edit Configuration برای تنظيم مشخصات فايل Web.Config بدون نياز به دسترسی مستقيم به فايل Web.Config است.

تنظيمات اضافه شده به API
همچنين شما کلاس System.Configuration.Configuration را در اختيار داريد. اين API به شما کمک می کند به فايلهای تنظيمی XML از طريق کدهای برنامه دسترسی داشته باشيد.اين به شما اجازه می دهد ابزارهای جديدی ايجاد کنيد. کد زير روش فعال کردن Authentication را برای برنامه کاربردی روی Local Machine نشان می دهد:

[C#]
Configuration cfg = Configuration.GetConfigurationForUrl("/Application_name");
Response.Write( cfg.Web.Authentication.Mode.ToString() );

[VB.NET]
Dim cfg As Configuration =
Configuration.GetConfigurationForUrl("/Application_name")
Response.Write( cfg.Web.Authentication.Mode.ToString() )

کد زير نيز حالت authentication Forms-Based را برای يک برنامه کاربردی فعال می کند:

[C#]
Configuration cfg = Configuration.GetConfigurationForUrl("/MyApp");
cfg.Web.Authentication.Mode = HttpAuthenticationMode.Forms;
cfg.Update();

[VB.NET]
Dim cfg As Configuration = & _
Configuration.GetConfigurationForUrl("/MyApp")
cfg.Web.Authentication.Mode = HttpAuthenticationMode.Forms cfg.Update()

تمام خصوصيات بالا به شما کمک می کنند که مقدار وقت و تلاشتان را برای انجام تنظيمات برنامه های کاربردی کاهش دهيد.

تغييرات در Development
ASP.NET 2.0 و Visual Studio 2005 همچنين مقدار زيادی از تغييرات مورد نياز برای گسترش برنامه های کاربردی وب در طول زمان را تغيير داده اند. در اين بخش نگاهی به برخی از خصوصيات جديد می اندازيم که در ASP.NET 1.x نيز موجود بوده اند و اکنون کاملتر شده اند يا تغيير کرده اند.

ارتباط با Server
در ASP.NET 1.x و نسخه های قديمی Visual Studio .NET شما برای ارتباط با يک IIS بايد از Microsoft FrontPage Server Extensions استفاده می کرديد. به عنوان يک طراح شما همچنين بايد برای ايجاد سايتهای جديد به IIS دسترسی می داشتيد که اين برای شرکتهای بزرگ ايجاد مشکلاتی می کرد، پس اين فرآيند تسهيل شد:

The Development Server
اول برای گسترش Visual Studio .NET 2005 يک Server ساخته شده به بازار آمده اين Web Server فقط از طريق درخواستهای محلی قابل دسترسی است. بنابر اين از نظر امنيتی قابل اطمينان نيست. اين Server خصوصيات جديد خطايابی را پشتيبانی می کند و می تواند به عنوان يک ابزار گسترش برای برنامه های کاربردی جديد وب به کار رود. زمانی که شما آماده انتقال و نصب نهايی برنامه های خود بوديد به سادگی می توانيد آنها را به IIS منتقل کنيد.

The Production Server
اکنون زمانی که شما به IIS وصل می شويد انتخابهای متعددی داريد. زمانی که يک برنامه کاربردی وب را در Visual Studio .NET باز می کنيد شما برای انتخاب متد Connection مورد سوال قرار می گيريد.

شما می توانيد Microsoft FrontPage Server Extensions ،FTP ،Share Point يا مکانيسم های گوناگون ديگر را نيز برای انتقال فايلها به Server مورد استفاده قرار دهيد.

کامپايل کردن برنامه های کاربردی ASP.NET 2.0
تغيير بزرگ ديگر در ASP.NET 1.x مربوط به راه هايی است که برنامه های کاربردی وب می توانند کامپايل شوند. در ASP.NET 1.x برنامه ها در زمان اولين درخواست يا حالت Batch در زمان Start Up کامپايل می شدند. هر دو روش مزايا و معايبی داشتند. مهمترين عيب آنها اين بود که شما بايد کدهای کامپايل نشده را به Server می فرستاديد که اين می توانست بسته به نوع مديريت امنيتی شما برای نيازهای امنيتی خطر ساز باشد.

ASP.NET 2.0 متد جديد کامپايل کردن را در اختيار شما می گذارد که همان Pre-Compile کدهای داخلی به اسمبلی های باينری برای نصب (deployment) است که در نتيجه برنامه ها روی اسمبلی هايی که می توانند برای مدت طولانی نامگذاری و علامت گذاری شوند و فايلهای منبع گوناگون مثل تصاوير بنا می شوند.پس برنامه کاربردی Pre-Compile شده دارای امنيت بيشتری نسبت به برنامه های عادی ASP.NET است.

قسمت دوم

همه مقالات کليات ASP.NET را ببينيد.
جستجو: بگرد!
جستجوی پيشرفته
نام کاربری |
کلمه عبور |


IranASP.NET - کوچ از ASP.NET 1.x به ASP.NET 2.0 - قسمت دوم

کوچ از ASP.NET 1.x به ASP.NET 2.0 - قسمت دوم

کيوان نيّری | اين مقاله ۳۴۵۲ بار تاکنون ديده شده است.
۱۳۸۳/۶/۲۵ | برای وبلاگ برای وبلاگ
نسل اول ASP.NET در قالب نسخه‎های 1.0 و 1.1 ارائه گشت. گذشت زمان و کسب تجربيات متعدد، پيدايش نيازهای جديد، ضعف های موجود و نيز به دليل ايجاد راه حل‎های تکراری ولی پرکاربرد توسط برنامه نويسان جهت حل برخی مسائل که همواره وقت زيادی را از آنها می گرفت، همگی سبب شدند تا مايکروسافت به فکر گسترش تکنولوژی NET. و ASP.NET به عنوان جزء مهمی از آن باشد. حاصل کار پيدايش نسخه بهتر شده دات نت و مهمتر از آن ASP.NET 2.0 جهت ارائه در سال 2005 بود.

قسمت اول

Navigation در سايت
يکی از مشکلات عمده و معمول در ASP.NET 1.x کار با کنترلهايی است که نياز به آدرس نسبی صفحات ديگر در سايت را دارند مثل کنترل HyperLink که برای اشاره به به صفحه ديگری روی سايت آدرس نسبی آن صفحه را می پذيرد. حال اگر اين صفحه در يک شاخه قرار داشته باشد و اين کنترل به صفحه ای در شاخه ديگری اشاره کند با جابه جا شدن صفحه اول اين آدرس نسبی نيز بايد تغيير کند. ASP.NET 1.x راه حل مناسبی برای اين مشکل ارائه نکرده بود و شما بايد کدهای HTML داخل کنترل ها را تغيير می داديد. ASP.NET 2.0 خصوصيات جديد مناسبی برای بهبود Navigation در سايت و کاهش نياز به تغيير و عمليات درصفحات وب را ارائه می کند.

ASP.NET 2.0 به شما اجازه می دهد برنامه های کاربردی خود را بر مبنای يک ساختار منطقی (Logical Structure) تعريف کنيد. استفاده از ساختار منطقی برای Navigation به شما کمک می کند تا يک مسير Navigation برای برنامه های کاربردی خود با استفاده از رابطه بين صفحات وب به جای مبنا قرار دادن آدرس هر يک از صفحات وب به طور منفرد تعريف کنيد. با اين روش شما می توانيد صفحات خود را دچار تغيير ساختار کنيد بدون آنکه نيازی به تغيير کدها باشد. با استفاده از ساختار منطقی همچنين نيازهای مربوط به Navigation مثل Menu ها ، Tree View ها و ... نيز برطرف می شود.

فايل Web.SiteMap
کلاس SiteMap در ASP.NET 2.0 ساختار منطقی را برای وب سايت شما برآورده می کند. شما می توانيد اين ساختار را با استفاده از XML يا تامين کننده Navigation که در ASP.NET 2.0 موجود است تعريف کنيد يا می توانيد از تمام ساختارهای ديگر داده و تامين کننده دلخواه استفاده کنيد. بعد از اينکه يک بار کليت کار را تعريف کرديد می توانيد از ساختار Navigation در راه های مختلفی استفاده کنيد. يک ساختار منطقی (Logical Structure) می تواند با دو گام ساده ساخته شود:

۱- ايجاد يک فايل XML که با نام Web.SiteMap اجرا می شود که صفحات موجود در سايت را در يک روش سلسله مراتبی قرار می دهد. Visual Studio.NET 2005 به شما اجازه می دهد فايل های جديد با پسوند Site. را با انتخاب گزينه Add New Item و انتخاب قالب SiteMap ايجاد کنيد و در زمان کار با اين نوع فايل ها Intellisense به شما کمک می کند.

<?xml version="1.0" encoding="utf-8" ?>
<siteMap>
<siteMapNode title="Home" url="default.aspx">
<siteMapNode title="Article 1" url="~/articles/demoarticle1.aspx" />
<siteMapNode title="Article 2" url="~/articles/demoarticle2.aspx" />
<siteMapNode title="Article 3" url="~/articles/demoarticle3.aspx" />
</siteMapNode>
<siteMapNode title="Picture Gallery" url="~/PhotoAlbum/PhotoAlbums.aspx">
<siteMapNode title= "Meetings"url="~/PhotoAlbum/PictureAlbum.aspx?albumid=1"/>
<siteMapNodetitle="Activities"url="~/PhotoAlbum/PictureAlbum.aspx?albumid=2"/>
<siteMapNode title= "Training"url="~/PhotoAlbum/PictureAlbum.aspx?albumid=3"/>
</siteMapNode>
</siteMap>

۲- انتخاب کنترل SiteMap DataSource از ToolBox و وارد کردن آن به صفحه (Drap & Drown آن). اين کنترل به طور خودکار به ساختار منطقی سايت که شامل Web.SiteMap می شود مقيد می گردد تا زمانی که کنترل SiteMap DataSource روی صفحه است شما می توانيد به سادگی آنرا به کنترلهای ديگری مثل Tree View و Menu ها مقيد کنيد.

<%@ page language="VB" master="~/Mysite.master" %>
<asp:content id="Content1" contentplaceholderid="LeftSideContent">
<H2>Navigation </h2>
<asp:treeview id="Navigation tree" runat="server" datasourceid="NavSource"/>
</asp:content>

کنترلهای Navigation
ASP.NET 2.0 همچنين مجموعه ای از کنترلهای Navigation که می تواند با سرويس Navigation در سايت استفاده شوند به شما ارائه می کند. با استفاده از کنترلهای <asp:Menu> و <asp:TreeView> شما می توانيد يک ساختار Navigation هميشگی برای برنامه خود ايجاد کنيد. کنترل جديد <asp:SiteMapPath> برای عمومی کردن يک ساختار Navigation برای يک Bread Crum Trail استفاده شود.

نقشه گذاری URL
خصوصيت جديد ديگر ASP.NET 2.0 برای Navigation نقشه گذاری URL است. سايت ها معمولا نياز به URL های طولانی، سخت و پيچيده دارند (به URL ها MSDN نگاه کنيد!!). اگر شما بخواهيد URL های خود را در يک برنامه کاربردی ASP کلاسيک مخفی کنيد شما بايد يک ISAPI Handler مناسب برای پردازش دوباره درخواست ها بنويسيد. ASP.NET 2.0 تنظيمات URL Mapping را به فايل Web.Config اضافه کرده است که با استفاده از آن يک برنامه نويس می تواند يک نقشه گذاری برای مخفی کردن يک URL به URL های مناسب برای کاربر ايجاد کند.

<urlMappings enabled="true">
<add url= "~/Home.aspx"mappedUrl="~/Default.aspx?tabid=0" />
</urlMappings>

تنظيمات نشان داده شده در بالا بايد تمام درخواستها برای صفحه Home.aspx را نقشه گذاری ( و Redirect) کند به صفحه Default.aspx?tabid=0

دسترسی به داده ها و منابع داده
دسترسی به داده ها در ASP.NET 1.x بر مبنای Connection ها و Command هايی است که اطلاعاتی را که می توانند به کنترلهای مختلف ASP.NET مقيد کنند.

ASP.NET 2.0 ارتباط با ADO.NET را با تامين کردن منابع داده ای که کدها را برای باز کردن کپسولهای Connection ها و Command در يک فايل XML در داخل فايل Web.Config به کار می گيرد. مثل ASP.NET 1.x شما می توانيد يک Wizard را در Visual Studio 2005 را برای ايجاد منابع داده ای به کار گيريد. ASP.NET 2.0 با منابع داده ای زير می تواند مرتبط شود:

Microsoft Access: منبع داده ای Access می تواند به طور خودکار به يک پايگاه داده ای Access متصل شده و Query های مناسب را ايجاد کند.

اشيا(Objects): کنترل ObjectDataSource در بالای قسمت مرکزی رديف لايه داده ها يا ديگر مجموعه اشيا قرا دارد. شما می توانيد از اين شئ برای ارتباط دادن يک يا چند مجموعه داده ها که می توانند به کنترلهای مقيد سازی داده ها مرتبط شوند استفاده کنيد.

DataSet: منبع DataSetDataSource می تواند به داده های فهرستی مثل فايلهای مجزا شده با کاما يا فايلهای XML مرتبط شود.

XML: منبع XMLDataSource به داده های سلسله مراتبی در يک فايل XML متصل می شود. تفاوت اوليه بين XMLDataSource و DataSetDataSource در XMLDataSource است که برای مقيد سازی به کنترلهای سلسله مراتبی مثل TreeView مناسب تر است. همچنين DataSetDataSource برای کنترلهای فهرستی مثل DataGrid مناسب تر است.

نقشه سايت: SiteMapDataSource يک منبع داده ای برای کنترلهای Navigation در سايت فراهم می کند.

کنترلهای جديد مقيدسازی داده ها
ASP.NET 2.0 همچنين شامل دو کنترل جديد مقيد سازی داده ها است. کنترل اول GridView است که روی DataGrid با تامين کدهای قابل تنظيم برای ويرايش خانه های جدول نشان دادن سطرها در صفحات مختلف، مرتب سازی، پاک سازی، انتخاب و بقيه اعمال معمول بسط يافته است.

کنترل دوم DetailsView است که بررسی جزئيات مربوط به رابطه مکمل GridView و DataGrid را بر عهده دارد.

کنترل DetailView يک رکورد را در هر زمان به نمايش می گذارد که کنترل بيشتری را برای نمايش، ويرايش، پاک سازی و يا ايجاد رکوردها به شما می دهد.

برنامه های کاربردی Web برای دستگاه های Mobile
امکان دارد شما به عنوان يک برنامه نويس با برنامه های کاربردی ASP.NET با Microsoft Mobile Internet Toolkit يا MMIT و کنترلهای خاص موبايل مواجه شده باشيد. در ASP.NET 2.0 کنترلهای موبايل و MMIT به عنوان يک چارچوب کاری اصلی نقش ايفا می کنند. به طور معمول کنترلهای ASP.NET 2.0 مدل بازگشت توافقی که دارای رابطه مشابهی با کنترلهای قديم Mobile است تامين می کنند. تمام اين اعمال فقط در قالب يک بسته قال انعطاف و ساده برای استفاده در دسترس هستند.

خصوصيات جديد در ASP.NET 2.0
معمولا هر بروز رسانی کلی در يک چارچوب کاری با اضافه شدن خصوصيات جديد و کلی همراه می شود که در اين بخش به بررسی اين خصوصيات در ASP.NET 2.0 می پردازيم.

Master Pages
اين خصوصيت جديد به شما در طراحی و گسترش برنامه های کاربردی بر اساس يک ظاهر ثابت کمک می کند. اين خصوصيت به شما کمک می کند تا يک قالب ثابت را برای چندين صفحه وب طراحی کرده و در آنها استفاده کنيد.

اولين هدف Master Pages جلوگيری از نياز به طراحی يک قالب و تکرار کد آن در صفحات مختلف است. فايده ديگر اين خصوصيت اين است که اگر شما نيازی به تغيير قالب صفحات داشته باشيد به جای نياز به تغيير تمام صفحات تنها يک صفحه را تغيير می دهيد. اين خصوصيت مشابه تکنيک Visual Inheritance در فرمهای Microsoft Windows است.

Master Page ها مشابه صفحات ديگر ASP.NET هستند و تفاوت آنها تنها در محيط (که پسوند اين صفحات master. به جای aspx.) و برخی کنترلهای خاص است. Master Pages می توانند شامل يک يا چند کنترل <asp:ContentPlaceHolder> باشند. اين کنترلها نواحی مورد نياز برای تغيير در محتوا را شامل می شوند. اساساً هرچه در ContenetPlaceHolder نيست در تمام صفحات به نمايش در می آيد.

Visual Studio 2005 به طور خودکار بيشتر اين کد را برای شما ايجاد می کند پس شما نيازی به نوشتن کدهای پيچيده HTML نداريد. يک Master Page می تواند شامل قطعه کد زير باشد:

<%@ master language="C#" compilewith="site.master.cs" classname="ASP.site_master" %>
<html>
<head runat="server"><title>Untitled Page</title></head>
<body>
<form runat="server">
<asp:contentplaceholder id="ContentPlaceHolder1" runat="server">
</asp:contentplaceholder>
</form>
</body>
</html>

جدای از اين تغييرات کليدی هر Master Page می تواند شامل هر کنترلی که در صفحات عادی ASP.NET موجود است نيز باشد.

اگر چه Master Page ها و Frame ها دارای اهداف يکسانی هستند ولی Master Page ها وظيفه مندی خاصی را ارائه می کنند. بر خلاف Frameها استفاده از Master Page ها به شما قابليت های زير را می دهد.

۱- يک بار طراحی کنيد و به تعداد دلخواه استفاده نمائيد. بعبارت ديگر در اين حالت ساختار و نمای کلی يک صفحه از Master Page و محتوای آن از صفحه مربوطه گرفته می شود و در نهايت و برخلاف Frame ما تنها يک صفحه عادی وب خواهيم داشت.

۲- امکان استفاده آسان و راحت از انواع کنترلها به جای تگ های دست و پا گير HTML در مقايسه به Frameها و نحوه ساخت آنها. همه اين کارها توسط Visual Studio برای شما به آسانی انجام می گردد.

۳- سازگاری کامل صفحات محتوا با Master Pages. پس شما نبايد ترسی از اين داشته باشيد که ورود کدهای HTML محتوا به صفحه لايه های ديگر را تحت تاثير قرار دهد.

خلاصه اينکه Master Page ها به طرز بسيار جالبی فرآيند ساخت برنامه های کاربردی وب بر مبنای ظاهر ثابت را بدون توجه به تعداد صفحات ساده سازی کرده است.

صفحات محتوا (Content Pages)
صفحات محتوا به Master Page ملحق می شوند و يک محتوا را برای کنترلهای ContentPlaceHolder در Master Page ها تعريف می کنند. صفحه محتوا شامل کنترلهای <asp:content> است که به منبع کنترل <asp:contentPlaceHolder> در Master Page از طريق ContentPlaceHolder ID پيوند خورده است. صفحات محتوا و Master Page ها در يک دسترسی به صورت يک جا به هم می پيوندند.

<%@ page language="VB" master="~/Mysite.master" %>
<asp:content id="Content1" contentplaceholderid="LeftSideContent">
<H2>Navigation </h2>
<asp:treeview id="Navigation tree" runat="server" datasourceid="NavSource"/>
</asp:content>
<asp:content id="Content1" contentplaceholderid="RightSideContent">
<asp:label runat="server">Support section</asp:label>
</asp:content>

يک بار ديگر: کاربر حقيقتا يک درخواست را برای صفحه محتوا ارسال می کند ولی ASP.NET به طور خودکار اين محتوا را با Master Page آميخته و به کاربر ارسال می کند.

Master Page های تو در تو
در مثالهای مجزا Master Pageها بايد لايه بندی شوند تا دسترسی به کنترل روی سايت محقق شود. برای مثال ممکن است شرکت شما يک سايت داشته باشد که يک قسمت بالايی و پايينی ثابت برای هر صفحه دارد ولی بخش حسابداری شما قالب متفاوتی با بخش IT داشته باشد.

با استفاده از Master Pageهای لايه بندی شده در Master Page های سطح بالای شرکت، شما می توانيد کنترل کاملی روی محتوايی که به نمايش در می آيد داشته باشيد. نکته اساسی اين است که به ياد داشته باشيد در نهايت يک صفحه توسط يک کاربر درخواست شده و يک صفحه توسط او دريافت می گردد اگر چه ممکن است چند صفحه Master Page و محتوا مورد پردازش قرار گيرند.

باطل کردن Master Pageها
هدف اساسی Master Pageها ايجاد يک ظاهر ثابت برای همه صفحات در برنامه کاربردی شماست اگر چه ممکن است حالتهايی پيش آيد که ممکن است شما بخواهيد محتوای متفاوتی را به صفحه خود وارد کنيد. که برای حل اين مشکل به سادگی از يک کنترل محتوايی استفاده می کنيد.

برای باطل کردن خصوصيات يک Master Page به طور پويا شما بايد بخشهای عمومی (Public) کلاس Master Page را برنامه ريزی کنيد که شامل آن چيزهايی است که شما ايجاد کرده ايد. بنابراين اگر می خواهيد خصوصيات <title> و <keyword> از بخش <head> را در صفحات HTML باطل کنيد شما بايد تابعی بسازيد که خصوصيات پيش فرض را در Master Page شما ويرايش کند:

<head runat="server" id="Head1">
<title><% =m_HtmlTitle %></title>
<meta name="keywords" content="<% =GetKeywords() %>" >
<meta name="description" content="A newsletter focused on meeting the needs of .NET developers, providing cool tips for the advanced programmer, and keeping you informed on what's happening with .NET!" >
<LINK href="<% =Request.ApplicationPath %>/portal.css" type="text/css" rel="stylesheet">
</head>

Themes و Skins
می دانيد که يک طراح برای زيبا سازی و تغيير ظاهر صفحات خود نياز به استفاده از فايلهای CSS يا استفاده از CSS به صورت ضمنی دارد. اين مساله منجر به استفاده از يک شکل ثابت در صفحات می شود. برای حل اين مشکل نيز در ASP.NET 2.0 راه حلهايی در نظر گرفته شده است.

Themes
Theme ها مشابه CSS Styleها هستند چرا که هر دو برای تعريف خصوصيات و صفات معمول در يک يا چند صفحه به طور ثابت استفاده می شوند ولی به هر شکل Theme ها تفاوتهايی نيز با Style Sheet ها دارند:

۱- Theme ها می توانند خصوصيات زيادی را برای هر کنترل تعريف کنند در حاليکه Style ها فقط مجموعه ای از صفات معمول را تعريف می کنند.
۲- Theme ها می توانند شامل فايلهای مختلفی باشند در حاليکه CSS Style ها نمی توانند.
۳- Theme ها به مانند Style Sheet ها از شيوه نامه آبشاری استفاده نمی کنند.
۴- Theme ها می توانند شامل Refrence به Style Sheet ها باشند.

هر برنامه کاربردی يک شاخه Themes دارد. هر Theme خاص زير شاخه مخصوص به خود را دارد که شامل فايلهای Skin و بقيه فايلهای خود است.

تعريف يک Theme
شما می تونيد Theme ها و Skin ها را در زير شاخه هايی که از شاخه Themes مشتق می شوند تعريف کنيد.هر زير شاخه شامل يک Theme است. هر زير شاخه شامل فايلهای skins. است که به مانند ديگر منابع مورد استفاده توسط Theme ها مانند Style Sheet ها و تصاوير قرار گرفته اند.

تعريف معمولی و نرمال Skin در فايلهای Skin. موجود است و بسيار شبيه به تگهای مورد استفاده در نمونه کنترلهای فايلهای ASPX است. برای مثال، در شاخه Themes يک زير شاخه با نام Pink ايجاد کنيد. برای ايجاد يک فايل skin. برای Theme خود به سادگی کد زير را اضافه کنيد و در شاخه Pink ذخيره کنيد:

<asp:DropDownList runat="server" BackColor="hotpink" ForeColor="white" />
<asp:DataGrid runat="server" BackColor="#CCCCCC" BorderWidth="2pt"
BorderStyle="Solid" BorderColor="#CCCCCC" GridLines="Vertical"
HorizontalAlign="Left">
<HeaderStyle ForeColor="white" BackColor="hotpink" />
<ItemStyle ForeColor="black" BackColor="white" />
<AlternatingItemStyle BackColor="pink" ForeColor="black" />
</asp:DataGrid>

آنگاه Theme می تواند در تمام صفحات برنامه کاربردی شما مورد استفاده قرار گيرد. بنابر اين رنگ پس زمينه Data Grid شما به رنگ صورتی تيره در می آيد.

استفاده از يک Theme
Theme ها می توانند به صورتهای زير به کار روند:

۱- در صفحه با استفاده از تگ منفرد <% "page language="VB" theme="Pink @%>
۲- در تمام سايت با استفاده از المانهای تنظيمی فايل Web.config بصورت </"pages theme="Pink>

فايل Web.Config فايل اصلی تنظيمات برای هر برنامه کاربردی است. تاثير استفاده از Theme ها را می توانيد در کنترلهای خود ببينيد.

Skins
يک Skin مجموعه ای از قالبها و خصوصيات است که می تواند برای استاندارد سازی اندازه فونت و ديگر صفات کنترلها روی يک صفحه به کار رود. شما می توانيد Skinها را برای ايجاد يک ظاهر مشخصی برای کنترلها به کار گيريد که اين تنظيمات می تواند توسط شما يا کاربر در زمان دسترسی به صفحه صورت گيرد. Skinها می توانند با استفاده از خصوصيت SkinID در کنترلها در آنها به کار روند.

<!- Default Skin -->!>
<asp: label runat="server" Font-names="verdana, arial" font-size="10pt" ForeColor= "#000066" BackColor="transparent"/>
<!- Title Skin -->!>
<asp: label runat="server" id="foo" skinid="Title" Font-names="verdana, arial" font size="18pt" ForeColor= "#000066" BackColor="transparent" font-bold="true" font-underline="true"/>

وقتی يک بار يک Skin را تعريف کرديد می توانيد آنرا در کنترلهای مختلف خود که دارای SkinID هستند به کار گيريد.

به کار گيری يک Skin برای يک کنترل
اگر يک Skin پيش فرض موجود باشد و با استفاده از يک Theme تعريف شده باشد Skin پيش فرض به طور خودکار در يک کنترل استفاده می شود. اگر شما خصوصيت SkinID را برای کنترل تعريف کنيد، Skin پيش فرض با Skin خاصی که در خصوصيت SkinID به آن اشاره شده جا به جا می شود. اين خصوصيت می تواند در زمان گسترش يا اجرا تنظيم شود.

عضويت (User Membership)
يکی از مسائل در گسترش ASP مساله سيستم عضويت است که بايد از ابتدا توسط برنامه نويس طراحی شود. اين کار مشکل نيست ولی وقت گير است. سيستم عضويت و کنترلهای Login اين مساله را تا حد زيادی بهبود بخشيده است.

به طور خلاصه بايد گفت اين سيستم يک ساختار کامل برای عضويت کاربران و مديريت آن را برای شما ايجاد کرده است. اين سيستم اطلاعات را در يک پايگاه داده به صورت کاملا امن ذخيره می کند. اين سيستم به طور پيش فرض از Microsoft Access و Microsoft SQL Server پشتيبانی می کند. ولی شما می توانيد نيازهای دلخواه خود را از طريق ايجاد تنظيمات در فايل Web.Config ايجاد کنيد. همچنين شما می توانيد از کنترلهای جديد Login در ASP.NET 2.0 برای خودکار سازی سيستم ورود و خروج و ثبت نام کاربران استفاده کنيد.

کنترلهای Login
ASP.NET 2.0 کنترلهای Login را برای کمک به ايجاد و مديريت سيستم کاربری در اختيار شما می گذارد بدون آنکه نيازی به نوشتن حتی يک خط کد داشته باشيد. شما می توانيد به سادگی کنترل <asp:CreateUserWizard> را به صفحه خود وارد کنيد و از آن برای ثبت نام کاربران به صورت مرحله مرحله استفاده کنيد.

همچنين اين کنترلهای جديد محيط مناسبی را در اختيار شما می گذارند تا ظاهر آنها را با برنامه کاربردی خود منطبق کنيد. خصوصياتی مثل Label و Value و Error message validation نيز برای هر خصوصيت موجود است. با استفاده از کنترلهای LoginName و LoginStatus شما می توانيد به هر کاربر يک پيغام خوش آمد مناسب ارائه کنيد بدون آنکه نيازی به حتی يک خط کد داشته باشيد.

کنترل LoginView به شما کمک می کند تا مشخص کنيد چه محتوايی به هر کاربر نشان داده می شود (بدون نوشتن يک خط کد). محتوا با توجه به نقش و سطح دسترسی هر کاربر تعيين می شود. در برنامه های کاربردی ASP شما بايد کدهايی را برای انجام اين اعمال می نوشتيد تا پيامهای مناسب هر کاربر را نمايش دهد و محتوای مناسب هر کاربر را به او ارائه کند.

Profile ها
خصوصيات مربوط به Profile در ASP.NET 2.0 به شما اجازه می دهند تا اطلاعات هر کاربر که با سايت به اشتراک گذاشته را تعريف و ذخيره کنيد. در برنامه های ASP شما بايد کد نوشته شده خود را برای جمع کردن اطلاعات کاربر گسترش می داديد و برای session کاربر ذخيره می کرديد و در پايگاه های داده ای لازم ذخيره می کرديد. Profile ها مستقيما از طريق شئ Profile در هر صفحه ASPX قابل دسترسی اند.

تعريف يک Profile
از طريق فايل Wen.Config يا Machine.Config و مقادير <property> می توانيد اطلاعات کاربری مربوط به Profile مثل نام، آدرس و آدرس پست الکترونيک و... را برای هر کاربر تعريف کنيد.

<profile>
<group name="BillingAddress">
<add name="Street" type="System.String" />
<add name="City" defaultValue="Toronto" type="System.String" />
<add name="StateProv" type="System.String" />
<add name="ZipPostal" type="System.String" />
</group>
</profile>

بعد از ايجاد اين خصوصيات ASP.NET 2.0 به طور خودکار از محتوای آنها محافظت می کند.

استفاده از Profile ها
زمانی که يک Profile را تعريف کرديد Visual Studio 2005 به طور خودکار اطلاعات آن را از طريق شئ Profile در اختيار شما می گذارد.

Visual Studio 2005 همچنين به طور کامل Intellisense را برای هر Profile پشتيبانی می کند. هر زمانی که شما تغييری را در تعريف يک Profile انجام داديد Visual Studio به طور خودکار Intellisense را به درستی برای شما تغيير داده و به سرعت بعد از اعمال تغييرات در فايل Web.Config در اختيار شما می گذارد.

همه مقالات کليات ASP.NET را ببينيد.
جستجو: بگرد!
جستجوی پيشرفته
نام کاربری |
کلمه عبور |


IranASP.NET - بهترين راه يادگيری ASP.NET

بهترين راه يادگيری ASP.NET

مديريت سايت | اين مقاله ۸۷۳۳ بار تاکنون ديده شده است.
۱۳۸۳/۶/۳۱ | برای وبلاگ برای وبلاگ
همواره ايميل های زيادی بدستم رسيده است که می پرسند: بهترين راه يادگيری ASP.NET چيست؟ يا اينکه برای يادگيری ASP.NET از کجا بايد شروع کنيم؟ و سوالاتی از اين قبيل. در اين مقاله سعی کرده ام که تجربيات خودم را در اين زمينه با شما در ميان بگذارم و احتمالاً بتوانم جوابی کاربردی و عملی به اين سوال بدهم. سوالی که احتمالاً شما هم به دنبال جواب آن هستيد.

به نظر من به تعداد انسانها، راه برای يادگيری ASP.NET هست! شوخی نمی کنم، جدی می گويم. به نظر من هر شخصی روش يادگيری خودش را دارد. فرقی هم نمی کند که بخواهيد ASP.NET ياد بگيريد يا آشپزی يا هر چيز ديگری. شما همانطور که اگر بخواهيد آشپزی ياد بگيريد ممکن است از کتاب، کلاس، سعی و خطا، تجربه و حتی از وب استفاده کنيد، برای ASP.NET و اصولا هر چيز ديگری هم ممکن است از همين ابزار و راهها استفاده کنيد.

چيزی که من می خواهم بگويم توضيح واضحات است. اما چون خيلی ها سوال می کنند ناچارم اشاره ای به این موضوع داشته باشم. به نظر من بيشتر، افراد مبتدی و تازه کار هستند که نياز دارند که پاسخ اين سوال را بدانند چون کسانی که به نوعی ASP.NET را ياد گرفته اند يا با آن آشنا هستند خود می دانند که چه کار بايد بکنند و چگونه ياد بگيرند.

کتاب

خيلی از افراد سوال می کنند که مثلا کدام کتاب خوب است؟ به عقيده من برای يک فرد تازه کار که می خواهد با الفبای کار آشنا شود، هر کتابی در زمينه آموزش مقدماتی و کليات ASP.NET خوب و مفيد است. حتی بسياری از کتابهای تخصصی هم فصلهای اوليه خود را به آموزش و مرور مقدمات ASP.NET تخصيص می دهند. پس دنبال کتاب خاصی نباشيد. اولين کتابی را که بدست آورديد بنشينيد و بخوانيد. بالاخره هر کتابی هر چند سطح پائين هم که باشد آنقدر مطلب دارد که يک تازه کار را برای مدتها به خود مشغول کند.

حرفه‎ای ترها هم که خود می دانند دنبال چه هستند و چه کتابی به کارشان می خورد. دقت داشته باشيد که متاسفانه سطح کتابها جهت استفاده حرفه‎ای ها بسيار پائين است به گونه‎ای که آنها معمولاً کتاب مورد نظر خود را نمی توانند پيدا نمی کنند. لابد نويسندگان فکر می کنند که حرفه‎ای ها نيازی به کتاب ندارند و آنقدر توانا هستند که يا خودشان فکر کنند يا مطلب شان را در وب پيدا کنند. چيزی که بحث بخش بعدی اين مقاله است.

به هرحال آنقدر در کتابهای آموزشی ASP.NET در مورد فرم های وب و نحوه استفاده از ADO.NET برای ارتباط با بانک اطلاعاتی و XML گفته اند که هيچگاه در مورد چگونگی طراحی ساختار و لايه های خود برنامه يا سايت چيزی گفته نشده است. مقوله ای که بدون آن معماری را می ماند که آجر و سنگ و سيمان دارد اما نقشه ندارد.

سايتهای آموزشی

ابزار بعدی، استفاده از سايتهای آموزشی موجود در وب هست. باور کنيد که برخی مطالب ذکر شده در سايتهای آموزشی را هيچ وقت در هيچ کتابی نخواهيد يافت و اصولا آنها هيچوقت چاپ نمی شوند. بخصوص زمانی که داريد وارد قلمرو حرفه ای می شويد. با بکارگيری گوگل، اين گونه سايتها هيچوقت برای شما مخفی يا ناشناخته نمی مانند. به شرطی که در انتخاب کليد واژه‎ی جستجوی خود دقت کنيد.

سايتی مثل W3Schools و بخش آموزش سريع يا QuickStart مايکروسافت می توانند منابع خوبی از جنس دوره های آموزشی باشند. اما انتظار نداشته باشيد که در ديگر سايتهای آموزشی/مقاله‎ای ASP.NET بتوانيد دوره های منظم و مرحله به مرحله‎ی کلاسیک و جزوه ای پيدا کنيد. بيشتر سايتها پر هستند از مقاله های رنگارنگ و متنوع که لزوما وحدت موضوعی نداشته و صرفاً برحسب نياز خود برنامه نويسان تهيه شده اند. من اينگونه سايتها و مطالب را برای دوران پس از مقدماتی توصيه می کنم.

بيشتر اين سايتها دارای خبرنامه الکترونيکی رايگان می باشند. با عضويت در آنها و دريافت مرتب تيتر مطالب شان، آنها را زير نظر بگيريد و اگر مقاله‎ای داشتند که به کار شما می خورد، به سراغش رفته و استفاده کنيد. اين مساله سبب می شود که شما مجبور نباشيد که همواره به آن سايتها سر بزنيد يا همه مطالب شان را بخوانيد و يا احتمالا مقاله‎ی مفيدی را از دست بدهيد. از اين رو ست که همواره بر داشتن خبرنامه‎ی الکترونيکی برای سايتها و عضويت افراد در آنها تاکيد شده است. خوشبختانه سايت IranASP.NET هم از همان روزهای آغازين اين مهم را سرلوحه کار خود قرار داده است. دقت داشته باشيد که شما هر چه جلوتر برويد و حرفه‎ای تر شويد، وقت کمتری برای مطالعه و يادگيری خواهيد داشت. بخصوص اگر به حدی برسيد که درگير يک کار يا پروژه هم بشويد!

کلاس

کلاس های آموزشی هم می توانند مفيد باشند. به گونه ای که در مدت زمان کوتاهی سرنخ مطالب جديدی را به شما می دهند و گاهاً ممکن است مطلبی را مطرح کنند که شما هيچ وقت در حالت خودآموزی به آن برخورد نکنيد. به کلاسهای آموزشی صرفا به عنوان نقطه شروع نگاه کنيد و نه چيز ديگر. هيچ کلاسی نمی تواند ادعا کند که شما را يک ماهه يا بيشتر به يک برنامه نويس حرفه ای وب تبديل می کند که اگر ادعا کرد خود معيار خوبی است جهت ميزان صداقت گردانندگان آن کلاس و سطح آن.

معمولاً شما نمی توانيد قبل از تشکيل يک کلاس به ميزان مفيد بودن آن برای يادگيريتان پی ببريد. هر چقدر هم از گردانندگان آن سوال کنيد، آنها آنقدر کلمات فنی و قلمبه سلمبه بلد هستند که شما فکر کنيد بيسواد مطلق هستيد. نمی گويم که همه‎ی کلاس ها اينگونه هستند و يا اينکه شما بدون تحقيق و بررسی به هر کلاسی برويد. اما می گويم که اندکی هم ريسک پذير باشيد چون ممکن است از هزينه و وقت تان آنگونه که انتظار داشته باشيد در پايان کلاس بهره نبرده باشيد. اين را کاريش نمی توان کرد و از ملزومات کار است که البته اشکالی هم ندارد و همين مساله خود برای شما نکته‎ی آموزشی خواهد شد اگرچه در زمينه ASP.NET هم نباشد!

از ديگر فوايد کلاس می توان به امکان پيدا کردن دوست و يا همکار و مهم تر از همه پروژه اشاره نمود. خيلی از همکارهای کاری و پروژه ای می تواند از درون همين کلاس ها رقم بخورد چه برای دانشجويان چه برای شخص مدرس!

زبان زبان زبان
بله، زبان البته از نوع انگليسی آنقدر مهم است که سه بار در عنوان اين بخش تکرار شود. اين را من برای شما که فارسی زبان هستيد می گويم. شما نمی توانيد يک برنامه نويس وب باشيد اما زبان انگليسی بخصوص در زمينه خواندن يا همان Reading را بلد نباشيد. چون شما نمی توانيد همه مطالب خود که هيچ بلکه حتی کسری از آن را هم به زبانی غير از انگليسی پيدا کنيد.

شما برای خواندن و يادگيری به زبان نياز داريد. همه‎ی کتابها انگليسی هستند و آنهايی هم که مثلاً ترجمه فارسی شده اند را خيلی جدی نگيريد. آنها بيشتر بدرد ناشرشان می خورد و کمی هم مترجم شان و نه شما. شما بايد اصطلاحات را به شکل انگليسی شان ياد بگيريد و نه ترجمه های من در آوردی و عجيب و غريب فارسی. کتابهای فارسی در اين زمينه را اغلب کسانی ترجمه می کنند که به نوعی ماشين ترجمه هستند و حتی ممکن است ندانند که آنچه را ترجمه کرده اند به چه دردی می خورد.

خوشبختانه مطالب فنی کامپيوتری نمی توانند دارای متون پيچيده و سخت انگليسی باشند. عمده‎ی کلمات که اسامی خاص و اصطلاحات فنی هستند و بقيه هم افعال و کلمات ساده و معمولی زبان می باشند. پس شما قرار نيست که نمايشنامه‎ی شکسپير را بخوانيد.

همچنين شما برای برنامه نويسی تان و انتخاب اسامی متغيرها، کلاس ها و متدهای مورد نيازتان بايد بتوانيد اسامی با مسمايی را انتخاب کنيد. شما بايد بتوانيد شرح يا کامنتی هر چند کوچک در لابلای خطوط برنامه تان بنويسيد تا کد برنامه شما به يک غول دست نيافتنی تبديل نشود. شما بايد بتوانيد خيلی از برنامه های از پيش نوشته شده را بخوانيد و بفهميد. معنا و مفهموم اسامی انتخاب شده برای کلاس ها و متدها از ديد زندگی روزمره به فهم بيشتر شما از آن برنامه کمک می کند. همه‎ی اينها با دانستن زبان انگليسی ميسر است.

پس لطفاً قبل از ياد گرفتن ASP.NET و يا اينکه چگونه بايد از ADO.NET استفاده کرد از زبان خود مطمئن شويد. اگر ضعيف هستيد اول آن را تقويت کنيد و بعداً بيائيد.

پيش نياز

توجه داشته باشيد که جهت يادگيری ASP.NET که يک تکنولوژی جهت ساخت برنامه های تحت وب است و نه يک زبان برنامه نويسی، شما به پيش نيازهای زياد و متنوعی نياز داريد. باز تکرار می کنم که ASP.NET تکنولوژی است نه زبان برنامه نويسی. مفاهيم و مسائل زيادی جهت به کارگيری اين تکنولوژی مورد نياز است. بدون تسلط و نه صرفاً اطلاع از آنها شما نمی توانيد ASP.NET را ياد بگيريد. مواردی که به ذهنم می رسد را در زير فهرست وار به اطلاع شما رسانده ام. اگرچه ممکن است ليست کاملی نباشد ولی حداقل مهم ترها را دارد.

- شما بايد يک برنامه نويس کامپيوتر باشيد.
- شما بايد بر مفاهيم شئ گرايی مسلط باشيد.
- شما بايد يکی از زبانهای خانواده ++C يا Visual Basic را بدانيد.
- شما بايد بانک اطلاعاتی و زبان SQL را بدانيد.
- شما بايد مفاهيم وب و برنامه نويسی وب را بدانيد.
- شما بايد کار با محيط های Visual را بدانيد.
- شما بايد IIS را بشناسيد و فرق وب سايت و Virtual Directory و تنظيمات آن را بدانيد.
- شما بايد يک ويندوز-سرور کار خوب باشيد.
- کمی هم شناخت و ذوق هنری در طراحی صفحات و گرافيک وب داشته باشيد.
- ...
- شما بايد عاشق مايکروسافت باشيد!

بهترين راه يادگيری ASP.NET

حالا می خواهم به اصل سوال پاسخ دهم. شما داريد از يک فوت کوزه گری نه چندان مخفی مطلع می شويد. راه های مختلف را گفتم اما حالا می خواهم بهترين آن را بگويم. بهترين راه يادگيری ASP.NET چيست؟

پاسخ: کار

شما از موارد فوق تنها می توانيد مقدمات را ياد بگيريد يا اينکه گوش و چشم تان را با واژه هايی آشنا کنيد. برای ملکه شدن دانسته هايتان و حرفه‎ای بودن تان بايد کار کنيد. يعنی اينکه بايد برنامه بنويسيد. بايد درگير کار يا پروژه ای شويد. بايد زور بزنيد و درگير باشيد. بايد نيازمند باشيد. اگر از سر سيری يا صرفاً برای پُز دادن دنبال چيزی هستيد مطمئن باشيد چيزی ياد نمی گيريد مگر به اندازه همان پُز دادن.

شما نياز داريد که همه چيز را حتی مقدمات را هم عملاً و شخصاً تجربه کنيد. اين می توانيد از طريق تعريف پروژه های من درآوردی شخصی باشد يا يک کار تجاری واقعی. شما بايد در حين کار شلاق بخوريد تا فولاد آبديده شويد! هيچ چيز بجز يک کار جدی و واقعی نمی تواند به شما چيز ياد بدهد. اين چيزی است که خود من به شخصه تجربه کرده ام. در اين چند سال کتاب و سايتهای فراوانی را خواندم و مقالات زيادی را نوشتم اما هيچ يک به اندازه‎ی يک پروژه جدی سنگين به من آموزش نداد. بعبارت ديگر همه آن خواندنها لازم هستند ولی کافی نيستند. دوباره دقت کنيد: لازم هستند. بيهوده نيستند. اما کافی هم نيستند.

جهت يادگرفتن ASP.NET شما بايد پرحوصله، وقت دار، سمج، فعال، علاقه مند و پيگير باشيد.

همه مقالات کليات ASP.NET را ببينيد.
جستجو: بگرد!
جستجوی پيشرفته
نام کاربری |
کلمه عبور |


IranASP.NET - بررسی خطاها در ASP.NET - قسمت اول

بررسی خطاها در ASP.NET - قسمت اول

نسرین قاسمپورملکی | اين مقاله ۳۵۲۳ بار تاکنون ديده شده است.
۱۳۸۳/۷/۲۵ | برای وبلاگ برای وبلاگ
هنگامی که در یک صفحه ASP.NET خطایی رخ می دهد، ASP.NET اطلاعاتی راجع به خطا به Client می فرستد. در اين مقاله به نحوه راه اندازی و اعلام خطاها به کاربر،نمایش یا عدم نمایش خطاها برای کاربران، سفارشی کردن صفحات خطا و نوشتن خطاها در Event Log می پردازيم.

• سفارشی کردن(Customize) صفحات خطا
• بررسی خطاها بوسیله برنامه نویسی
• نوشتن در گزارش رویداد(Event Log)
• خلاصه بخش

هنگامی که در یک صفحه خطایی رخ می دهد، ASP.NET اطلاعاتی راجع به خطا به Client می فرستد. خطاها به چهار دسته تقسیم می شوند:

• خطاهای وضعیتی(Configuration errors): هنگامی رخ می دهد که ترکیب و یا ساختار فایل Web.config در سلسله مراتب ترکیبی(Configuration) نادرست باشد.
• خطاهای مفسر(Parser errors): هنگامی رخ می دهد که اصطلاحا Syntax يا ترکیب ASP.NET در یک صفحه ناقص باشد.
• خطاهای زمان کامپایل(Compilation errors): هنگامی رخ می دهد که جملات(Statements) در یک صفحه در زبان(Language) تعیین شده، نادرست باشد.
• خطاهای زمان اجرا(Run-time errors): هنگام اجرای یک صفحه رخ می دهد، و این خطاها در زمان کامپایل قابل شناسایی نیستند.

در حالت پیش فرض، اطلاعاتی که جهت خطای زمان اجرا نمایش داده می شود بصورت فراخوانی از پشته هستند (زنجیره ای از فراخوانی های رویداد که وقفه را راه اندازی می کند). هنگامی که مد اشکالزدایی فعال باشد، ASP.NET شماره خطی از کد که خطای زمان اجرا در آن واقع شده نشان می دهد. مد اشکالزدایی یک ابزار مفید جهت اشکالزدایی برنامه است. مد اشکالزدایی در سطح صفحه توسط کد زیر فعال می شود:

<%@ Page Debug="true" %>

مد اشکالزدایی در سطح برنامه نیز با استفاده از فایل Web.config در شاخه اصلی بصورتی که در مثال نشان داده شده فعال می شود.

<configuration>
<system.web>
<compilation debug="true"/>
</system.web>
</configuration>

نکته:اجرا در مد اشکالزدایی موجب کاهش محسوس کارایی برنامه می شود. قبل از انتشار نسخه پایانی برنامه خود حتما این مد را غیرفعال کنید.

سفارشی کردن صفحات خطا

بسته به شرایط محیط نیاز به بررسی خطاهای برنامه به روشهای مختلفی می باشد.برای مثال، زمان برنامه نويسی(Development) احتمالا نیاز به مشاهده جزئیات صفحات خطا که ASP.NET جهت راهنمایی شناسایی و تصحیح مشکلات فراهم کرده، می باشد. اما اگر برنامه در مرحله استفاده توسط کاربر باشد احتمالا نیاز به نمایش جزئیات خطا برای کاربر نیست که می توان از قابلیت عدم نمایش خطا برای clientهای محلی(Local) در ASP.NET استفاده کرد (clientهای موجود در همان کامپیوتر سرور). برای راهنمایی clientها می توان هنگام بروز خطا آنها را به صفحه خطایی هدایت کرد.

مثال سفارشی کردن خطاها در فایل Web.config برای برنامه ها:

<configuration>
<system.web>
<customErrors defaultRedirect="genericerror.htm" mode="RemoteOnly" />
</system.web>
</configuration>

توسط کد زیر clientهای محلی می توانند صفحه پیش فرض جزئیات خطا ASP.NET را ببینند اما clientهای دیگر(Remote) به صفحه سفارشی
genericerror.htm هدایت می شوند. این صفحه میتواند یک صفحه aspx. نیز باشد.ASP.NET مسیر صفحه ای که خطا در آن رخ داده را به شکل یک آرگومان QueryString به صفحه خطا می فرستد. توجه شود که اگر اجرای صفحه خطا هم خطایی تولید کند یک صفحه خالی به client غیر محلی(Remote) ارسال می شود.

<%@ Page Language="C#" Description="Error page"%>

<html>
<head>
<title>Error page</title>
</head>

<body>
<h1>Error page</h1>
Error originated on: <%=Request.QueryString["ErrorPage"] %>
</body>
</html>

نکته: تنها فایلهایی که در aspnet_isapi.dll در IIS نگاشته شده اند، اینگونه خطاها را ایجاد می کنند. فایلهایی که در aspnet_isapi.dll بکار نرفته اند، توسط ASP.NET انجام نمی شوند و خطای IIS ایجاد می کنند. برای اطلاعاتی راجع به وضعیت(Configuration) خطاهای سفارشی IIS به مستندات IIS مراجعه کنید.

در زیر وضعیت attributeها و مقادیر برچسب <customErrors> را تشریح می کند.

Attribute | توضیح
mode | نشاندهنده فعال یا غیر فعال بودن خطاهای سفارشی و یا نمایش و عدم نمایش آن برای کامپیوترهای راه دور(Remote) می باشد. مقادیر:On،Off ،RemoteOnly(پیش فرض).
defaultRedirect | نشاندهنده آدرس پیش فرضی که جستجوگر باید هنگام بروز خطا به آن رجوع کند، می باشد.این خاصیت اختیاری است.

خاصیت Mode مشخص می کند که آیا خطاها برای clientهای محلی و یا clientهای راه دور و یا هر دو نمایش داده شوند. نتایج هر کدام از تنظیمات در زير شرح داده شده است.

Mode | Local host request | Remote host request
On | صفحه خطای سفارشی. | صفحه خطای سفارشی.
Off | صفحه خطای ASP.NET . | صفحه خطای ASP.NET .
RemoteOnly | صفحه خطای ASP.NET . | صفحه خطای سفارشی.

مثال زیر نشان می دهد چگونه ترکیب <customErrors> استفاده می شود.

[Web.config]
<configuration>
<system.web>
<customErrors defaultRedirect="genericerror.htm" mode="On"/>
</system.web>
</configuration>

[Genericeroor.htm'
<html>
<head>
<title>An Error Has Occured</title>
</head>
<body bgcolor="beige">
<font face="verdana">
<h4>We're Sorry...</h4>
An error has occured on the page you were requesting. If this problem persists, please contact the site administrator.
<p>
<hr>
</font>
</body>
</html>

[Custom1.aspx]
<html>

<script language="C#" runat="server">

void Error_500(Object sender, EventArgs e) {
String foo = null;
Response.Write(foo.ToString());
}

</script>

<body>
<form runat="server">
<h4><font face="verdana">Cause an Error to Occur...</font></h4>
<asp:button text="500 Server Error" OnClick="Error_500" width="150" runat="server"/><p>
</form>
</body>

</html>

علاوه بر هدایت به سمت صفحه عمومی برای همه خطاها، می توان برای کد خاصی از خطاها، صفحات خاصی را مشخص نمود. ترکیب <customErrors> از برچسب داخلی<error> که کدهای HTTP را به صفحات خطای سفارشی مرتبط می کند، پشتیبانی می کند. برای مثال:

<configuration>
<system.web>
<customErrors mode="RemoteOnly" defaultRedirect="/genericerror.htm">
<error statusCode="500" redirect="/error/callsupport.htm"/>
<error statusCode="404" redirect="/error/notfound.aspx"/>
<error statusCode="403" redirect="/error/noaccess.aspx"/>
</customErrors>
</system.web>
</configuration>

جدول زیر attributeها و مقادیر برچسب<error> را شرح می دهد.

Attribute توضیح
StatusCode کد خطای HTTP، که صفحه خطای سفارشی باید آن را استفاده کند.مثال:
403 Forbidden، 404 Not Found، یا 500 Internal Server Error .
Redirect آدرسی که جستجوگر client در صورت بروز خطا باید به سمت آن هدایت شود.

مثال زیر نشان می دهد که چگونه از برچسب<error> استفاده کنیم. توجه شود که مثال یک صفحه aspx را برای خطای "File Not Found"مشخص کرده است و آدرس صفحه مفقود شده ازطریق QueryString ارسال می شود.

    [Custom2.aspx]
<html>

<script language="C#" runat="server">

void Error_404(Object sender, EventArgs e) {
Response.Redirect("nowhere.aspx");
}

void Error_500(Object sender, EventArgs e) {
String foo = null;
Response.Write(foo.ToString());
}

</script>

<body>
<form runat="server">
<h4><font
    face="verdana">Cause an Error to Occur...</font></h4>
<asp:button text="404 Not Found"
    OnClick="Error_404" width="150" runat="server"/><p>
<asp:button text="500 Server
    Error" OnClick="Error_500" width="150" runat="server"/><p>
</form>
</body>

</html>

[Notfound.aspx]
<%@ Page Language="C#" %>
<html>
<head>
<title>An Error Has Occured</title>
</head>
<body bgcolor="ccffcc">
<font face="verdana">
<h4>We could not locate the page you requested...</h4>
<% if ( Request.QueryString["aspxerrorpath"] != null ) { %>
<%=HttpUtility.HtmlEncode(Request.QueryString["aspxerrorpath"])%>
<% } %>
<p>
Perhaps you mis-typed the URL? Please try again, or visit our search page for help.
<p>
<hr>
</font>
</body>
</html>

[Web.config]
<configuration>
<system.web>
<customErrors defaultRedirect="genericerror.htm" mode="On">
<error statusCode="404" redirect="notfound.aspx"/>
</customErrors>
</system.web>
</configuration>

قسمت دوم

همه مقالات کليات ASP.NET را ببينيد.
جستجو: بگرد!
جستجوی پيشرفته
نام کاربری |
کلمه عبور |


IranASP.NET - بررسی خطاها در ASP.NET - قسمت دوم

بررسی خطاها در ASP.NET - قسمت دوم

نسرین قاسمپورملکی | اين مقاله ۳۶۰۸ بار تاکنون ديده شده است.
۱۳۸۳/۸/۱۰ | برای وبلاگ برای وبلاگ
هنگامی که در یک صفحه ASP.NET خطایی رخ می دهد، ASP.NET اطلاعاتی راجع به خطا به Client می فرستد. در اين مقاله به بررسی سفارشی کردن صفحات خطا، بررسی خطاها بوسیله برنامه نویسی و نوشتن خطاها در Event Log می پردازيم.

قسمت اول

بررسی خطاها بوسیله برنامه نویسی
خطاها را میتوان در هر دو سطح صفحه و برنامه توسط کد راه اندازی کرد. کلاس پایه Page دارای متد Page_Error است، که میتوان از خاصیت override آن در صفحات خود بهره برد. این متد هر زمان که اتفاق بی دلیلی در زمان اجرا رخ دهد، فراخوانی می شود.

<script language="C#" runat="server">

void Page_Error(Object source, EventArgs e) {
String message = "<font face=verdana color=red>"
+ "<h4>" + Request.Url.ToString() + "</h4>"
+ "<pre><font color='red'>"
+ Server.GetLastError().ToString() + "</pre>"
+ "</font>";

Response.Write(message);
}

</script>

مثال زیر متدPage_Error را نشان میدهد.

[error2.aspx]
<html>

<script language="C#" runat="server">

void Error_500(Object sender, EventArgs e) {
String foo = null;
Response.Write(foo.ToString());
}

void Page_Error(Object sender, EventArgs e) {
String message = "<font face=verdana color=red>"
+ "<h4>" + Request.Url.ToString() + "</h4>"
+ "<pre><font color='red'>" + Server.GetLastError().ToString() + "</pre>"
+ "</font>";

Response.Write(message);
Server.ClearError();
}

</script>

<body>
<form runat="server">
<h4><font face="verdana">Cause an Error to Occur...</font></h4>
<asp:button text="500 Server Error" OnClick="Error_500" width="150" runat="server"/><p>
</form>
</body>

</html>

می توان برخی اقدامات مفید ازقبیل ارسال یک ایمیل به مسئول سایت برای گفتن اینکه صفحه بدرستی اجرا نشده، انجام داد.ASP.NET مجموعه کلاسهایی در فضانام System.Web.Mail دقیقا به همین منظور داراست. برای فراخوانی این فضانام از دستور @Import در بالای صفحه خود به شکل زیر استفاده می کنیم:

<%@ Import Namespace="System.Web.Mail" %>

میتوان از اشیاء MailMessage و SmtpMail جهت ارسال برنامه وار ایمیل استفاده نمود.

MailMessage mail = new MailMessage();
mail.From = "automated@www.contoso.com";
mail.To = "administrator@www.contoso.com";
mail.Subject = "Site Error";
mail.Body = message;
mail.BodyFormat = MailFormat.Html;
SmtpMail.Send(mail);

مثال زیر نشان میدهد که چگونه ایمیلی در پاسخ به خطای صفحه ارسال می شود.

نکته: این مثال در حقیقت تا زمانی که سرویس Mail SMTP بر روی سیستم فعال نشده باشد، ایمیلی ارسال نمی کند. برای اطلاعات بیشتر در رابطه با سرویس Mail SMTP، در مستندات IIS جستجو شود.

[error3.aspx]
<%@ Import Namespace="System.Web.Mail" %>

<html>

<script language="VB" runat="server">

Sub Error_500(sender As Object, e As EventArgs)
Dim foo As String = Nothing
Response.Write(foo.ToString())
End Sub

Sub Page_Error(Sender As Object, E As EventArgs)
Dim message As String = "<font face=verdana color=red>" _
& "<h4>" & Request.Url.ToString() & "</h4>" _
& "<pre><font color=red>" & Server.GetLastError().ToString() & "</pre>" _
& "</font>"

Response.Write(message)
Response.Write("An error has occured on this server, and the administrator of the site has been notified.")

Dim mail As New MailMessage
mail.From = "automated@www.contoso.com"
mail.To = "administrator@www.contoso.com"
mail.Subject = "Site Error"
mail.Body = message
mail.BodyFormat = MailFormat.Html
SmtpMail.Send(mail)

Server.ClearError()
End Sub

</script>

<body>
<form runat="server">
<h4><font face="verdana">Cause an Error to Occur...</font></h4>
<asp:button text="500 Server Error" OnClick="Error_500" width="150" runat="server"/><p>
</form>
</body>

</html>

علاوه بر راه اندازی خطاها در سطح صفحه، ممکن است نیاز به بررسی خطاها در سطح برنامه باشد. به همین منظور، از رویداد Application_Error در Global.asax استفاده می شود. این رویداد برای هر پیشامد غیرمنتظره ای در برنامه اجرا می شود.

void Application_Error(Object sender, EventArgs e) {
//...Do something here
}

نوشتن در گزارش رویداد (Event Log)

فضانام System.Diagnostics کلاسهایی را جهت نوشتن گزارش رویداد ویندوز مهیا کرده است. برای استفاده از این فضانام در صفحات، در ابتدا باید فضانام به شکل زیر فراخوانی شود:

<%@ Import Namespace="System.Diagnostics"%>

کلاس EventLog گزارش را در خود ذخیره می کند. همچنین متدهای ایستایی برای بازیابی و یا ایجاد گزارش فراهم ساخته و می تواند جهت نوشتن گزارش ارسالی از طریق کد، معرفی شود. مثال زیر مراحل را طی متد Application_Error از Global.asax نشان می دهد. هرگاه وقفه غیرمنتظره ای در برنامه اتفاق بیافتد، یک ورودی شامل پیغام خطا و ردیابی پشته در گزارش برنامه ایجاد می شود.

void Application_Error(Object sender, EventArgs e) {

String Message = "\n\nURL:\n http://localhost/" + Request.Path
+ "\n\nMESSAGE:\n " + Server.GetLastError().Message
+ "\n\nSTACK TRACE:\n" + Server.GetLastError().StackTrace;

// Create event Log if it does not exist

String LogName = "Application";
if (!EventLog.SourceExists(LogName)) {
EventLog.CreateEventSource(LogName, LogName);
}

// Insert into event log
EventLog Log = new EventLog();
Log.Source = LogName;
Log.WriteEntry(Message, EventLogEntryType.Error);

}

کد کاملی برای مثال بالا در زیر موجود است. توجه شود که این کد به جهت جلوگیری از ورود به گزارش رویداد ویندوز سیستم شما غیرفعال شده و بنابراین نمی تواند اجرا شود. اگر مایل به مشاهده اجرای این کد باشید یک ریشه مجازی IIS که دربرگیرنده شاخه شامل این فایل است، ایجاد کنید.

[Global.asax]
<%@ Import Namespace="System.Diagnostics" %>

<script language="C#" runat="server">

void Application_Error(Object sender, EventArgs e) {

String Message = "\n\nURL:\n http://localhost/" + Request.Path
+ "\n\nMESSAGE:\n " + Server.GetLastError().Message
+ "\n\nSTACK TRACE:\n" + Server.GetLastError().StackTrace;

// Create Event Log if it does not exist

String LogName = "Application";
if (!EventLog.SourceExists(LogName)) {
EventLog.CreateEventSource(LogName, LogName);
}

// Insert into Event Log
EventLog Log = new EventLog();
Log.Source = LogName;
Log.WriteEntry(Message, EventLogEntryType.Error);

}

</script>

خلاصه

1. خطاها به چهار رسته تقسیم می شوند:خطاهای وضعیتی،خطاهای پارسر،خطاهای زمان کامپایل، و خطاهای زمان اجرا.
2. بطور پیش فرض، اطلاعاتی که برای خطای زمان اجرا نمایش داده می شوند،بصورت فراخوانی از پشته می باشد(زنجیره ای از فراخوانی های رویداد که وقفه را راه اندازی می کند). هنگامی که مد اشکالزدایی فعال باشد، ASP.NET شماره خطی از کد که خطای زمان اجرا در آن واقع شده نشان می دهد.
3. قابلیت تعیین نمایش یا عدم نمایش خطاها به clientهای محلی، clientهای راه دور و یا هر دو در ASP.NET وجود دارد. بطور پیش فرض، خطاها فقط برای clientهای محلی (clientهای موجود در همان کامپیوتر سرور ) نمایش داده می شوند. همچنین می توان برای خطاهایی که بروز می کند ،کاربر را به صفحه خطای سفارشی هدایت کرد.
4. علاوه بر هدایت به سمت صفحه عمومی برای همه خطاها، می توان برای کد خاصی از خطاها، صفحات خاصی را مشخص نمود. ترکیب <customErrors> از برچسب داخلی<error> که کدهای HTTP را به صفحات خطای سفارشی مرتبط می کند،پشتیبانی می کند.
5. خطاها را میتوان در هر دو سطح صفحه و برنامه توسط کد راه اندازی کرد.کلاس پایه Pageدارای متد Page_Error است، که میتوان از خاصیت override آن در صفحات خود بهره برد.این متد هر زمان که اتفاق بی دلیلی در زمان اجرا رخ دهد،فراخوانی می شود.
6. فضانام System.Web.Mail کلاسهایی را جهت ارسال ایمیل از طریق برنامه در اختیار قرار می دهد که می تواند ابزار مفیدی جهت اعلام بروز خطا به مدیر برنامه باشد.
7. علاوه بر راه اندازی خطاها در سطح صفحه ، از رویداد Application_ErrorدرGlobal.asax برای بررسی خطاها در سطح برنامه استفاده می شود.این رویداد برای هر پیشامد غیرمنتظره ای در برنامه اجرا می شود.
8. فضانام System.Diagnosticsکلاسهایی را جهت نوشتن در گزارش رویداد ویندوز مهیا کرده است.

همه مقالات کليات ASP.NET را ببينيد.
جستجو: بگرد!
جستجوی پيشرفته
نام کاربری |
کلمه عبور |


IranASP.NET - لذت برنامه نويسی تحت وب با ASP.NET 2.0: بكارگيری Master Page ها

لذت برنامه نويسی تحت وب با ASP.NET 2.0: بكارگيری Master Page ها

Shahabfar.com Iranian .NET Community | اين مقاله ۳۴۷۸ بار تاکنون ديده شده است.
۱۳۸۳/۸/۱۸ | برای وبلاگ برای وبلاگ
ASP.NET 2.0 قابليت های جديدی را به همراه آورده است. يکی از مهمترين اين قابليتها اصطلاحا Master Page نام دارد. اين نوآوری شما را قادر می سازد تا به راحتی بتوانيد يک ظاهر واحد و يکسان برای کليه صفحات سايت خود بسازيد. اين مقاله به صورت قدم به قدم شما را با Master Page آشنا می کند.

اكثر قريب به اتفاق وب سايتها دارای يك قالب مشخص می باشند. بطوريكه اگر در آن وب سايت به گشت و گذار بپردازيم و صفحات مختلف آن را مرور كنيم متوجه می شويم كه همه صفحات از يك قالب خاص پيروی می كنند. بعنوان مثال لوگوی مربوط به معرفی وب سايت در همه صفحات وجود دارد. يا اينكه قسمتهای سمت راست يا سمت چپ كه معمولا" منويی از لينكها می باشند در تمام صفحات شكل ظاهری خود را حفظ می كنند. برنامه نويسان ASP.NET می دانند كه با معرفی User Control ها چه كمك شايانی به آنها جهت ايجاد قالب های ثابت و يا قابل تغيير برای يك وب سايت شد (البته كاربرد User Control ها تنها در ايجاد قالبها نيست). به كمك User Control ها می توانیم تا با يكبار ايجاد يك قالب و برنامه نويسی های مربوطه، آن را در هرصفحه aspx كه خواسته باشيم استفاده كنيم.

اكنون با عرضه ASP.NET 2 (نسخه بتا) و معرفی Master Page تهيه قالب برای يك وب سايت از آنچه كه فكرش را هم می كرديم ساده تر شده است. در اين مقاله قصد داريم تا شما را با نحوه ايجاد و استفاده از Master Page تحت ASP.NET 2 و در محيط Web Developer 2005 Express Edition آشنا كنيم. برای همقدم شدن در ايجاد و اجرای مثالی كه در اين مقاله ایجاد می شود به موارد زير نياز است.

- Web Developer 2005 Express Edition

- The .NET Framework 2 beta

- چند تصوير برای استفاده در لوگو و قسمتهای ديگر

ايجاد يك وب سايت:

برای ايجاد يك وب سايت با استفاده از ‌‌Web Developer و بر پايه ASP.NET 2 مراحل زير را دنبال كنيد.

١- در Web Dev از منوی فايل گزينه New Web Site را انتخاب كنيد كه با اينكار صفحه New Web Site ظاهر می شود.

٢- در زير گزينه Project Types زبان برنامه نويسی مورد نظرتان را انتخاب كنيد ( در اين مثال زبان#C انتخاب می شود). زبانی كه در اينجا انتخاب می شود بعنوان زبان پيش فرض در كل پروژه در نظر گرفته می شود ولی اين امكان برای شما مهیاست كه برای هر صفحه از اين پروژه يك زبان جداگانه را انتخاب كنيد.

٣- در زير عنوان Visual Studio installed templates گزينه ASP.NET Web Site را انتخاب كنيد.

٤- در قسمت Location نام مسيری را كه می خواهيد صفحات را در آنجا نگه داريد وارد كنيد. مثلا" C:\WebSite\WebSite1

اكنون Web Dev يك صفحه پيش فرض بنام Default.aspx برای شما ايجاد می كند. اين صفحه را ببنديد و به سراغ ايجاد يك Master Page برويد.

ايجاد يك Master Page

Master Page يك قالب برای صفحات شماست كه در واقع قالب بندی و ظاهر صفحات شما را مشخص می كند. در اين قسمت شما ابتدا يك Master Page ايجاد می كنيد. سپس با استفاده از يك table، آن را طوری تقسيم بندی می كنيم که بتوان در قسمت بالايی آن لوگوی سايت، در قسمت چپ منو و در پايين صفحه footer را قرار داد. شما همچنين با كنترل Content Placeholder آشنا خواهيد شد كه به كمك آن می توانيد محتوای صفحات مختلف را در Master Page داشته باشيد.

برای ايجاد يك Master Page :

١- در Solution Explorer بر روی نام وب سايتی كه ايجاد كرده ايد راست كليك كرده و گزينه Add New Item را انتخاب كنيد.

٢- در زير قسمت Visual Studio Installed Templates گزينه Master Page را انتخاب كنيد و نام آن را Master1 بگذاريد.

٣- گزينه Place code in separate file را انتخاب كنيد چرا كه می خواهيم كد نويسی در Code behind انجام شود.

٤- زبان مورد نظر خود را در قسمت Language انتخاب كنيد.

حال Master Page جديد در قسمت Source View ظاهر می شود. همانطور كه مشاهده می كنيد در قسمت بالای صفحه تعريف <% @ master … %> بجای وجود دارد. همچنين در قسمت body، كنترل asp.contentplaceholder وجود دارد كه محلی در Master Page می باشد كه در runtime محتويات صفحات مختلف در آن جايگزين می شود. در مورد اين كنترل در ادامه همين مقاله بيشتر می خوانيد.

شكل دادن به Master Page

Master Page مشخص می كند كه صفحات aspx چگونه در وب سايت شما به نظر آيند. Master Page می تواند شامل هر تركيبی از متن های استاتيك و وب كنترلها باشد. همچنين Master Page ها می توانند شامل چندين كنترل ContentPlaceholder باشند. كه مشخص كننده محل قرارگرفتن داده های ديناميك در هنگام نمايش صفحه می باشد.

در اين مقاله شما از يك table برای نسبت دادن مكانهايی خاص به المانهای موجود در Master Page استفاده خواهيد كرد. سپس كنترل ContentPlaceHolder را كه از قبل در Master Page موجود بوده است را در خانه ای از table جای گذاری خواهيم كرد.

برای اضافه كردن table و تغييرات مربوطه در Master Page بصورت زير عمل كنيد.

١- به قسمت Design View در صفحه Master Page برويد.

٢- با استفاده از پنجره مشخصات، رنگ پس زمينه Master Page يعنی گزينه BgColor را به دلخواه تغيير دهيد.

٣- از منوی Layout گزينه Insert Table را انتخاب كنيد.

٤- در صفحه Insert Table بر روی Tamplate كليك كنيد. از ليست موجود گزينه Header, footer and side را انتخاب كنيد.

٥- پس از اضافه شدن table ، مطابق زير اندازه خانه های آن را تغيير دهيد. عرض ستون سمت چپ برابر 80، ارتفاع رديف بالايی برابر 80، و ارتفاع رديف پايينی برابر 80

٦- رنگ پس زمينه هر سلول از table را به دلخواه تغيير دهيد و VAlign مربوط به هر سلول را در حالت top قرار دهيد.

برای اضافه كردن محتویات استاتيك به Master Page مطابق زير عمل كنيد.

١- سلول سمت راست پايين را انتخاب كرده و عبارتی نظير “Copyright … “ را در آن بنويسيد.

٢- از گروه Navigation موجود در toolbox يك كنترل Menu به سلول بالايی table اضافه كنيد (مشاهده می كنيد كه در ASP.NET 2 برای ايجاد منو ديگر نياز به كد نويسی نداريد. كنترل Menu تقريبا" همه امكانات منوهايی كه مد نظر داريد را در اختيار شما می گذارد). حال مشخصه Orientation از كنترل Menu را Horizontal انتخاب كنيد. از منوی Common Menu Task که در کنار کنترل Menu ظاهر می شود، گزينه Edit Menu Items را انتخاب كنيد.

٣- در زير عنوان Items، آيكون مربوط به اضافه كردن آيتم به منو را دوبار كليك كنيد تا دو آيتم به منو اضافه شوند. اولين آيتم را انتخاب كرده و Text آن را Home و NavigationUrl آن را به Home.aspx انتخاب كنيد. برای آيتم دوم Text را About و NavigationUrl را About.aspx انتخاب كنيد.

٤- يك تصوير را بعنوان لوگو در سلول بالايی table قرار دهيد.

برای اضافه كردن ContentPlaceHolder طريقه زير را بكار گيريد:

١- كنترل ContentPlaceHolder موجود رابه سلول سمت راست از رديف وسط table انتقال دهید.

٢- حاصل كار تا اينجا را ذخيره كنيد.

ايجاد محتوا برای يك Maste Page

شما با ايجاد يك صفحه ASP.NET كه ضميمه Master Page می شود. می توانيد محتوای يك Master Page را تعيين کنید. در اين مقاله شما دو صفحه aspx كه هر دو بعنوان محتوای Master Page تعيين می شوند را به پروژه اضافه خواهيد كرد. اين دو صفحه با توجه به آيتم هايی كه به منو اضافه كرده ايم قطعا" دو صفحه home و about خواهند بود.

برای اضافه كردن صفحه home.aspx چنين عمل كنيد:

١- بر روی نام وب سايت در قسمت Solution Explorer راست كليك كرده و Add New Item را انتخاب كنيد.

٢- در زير عنوان Visual Studio Installed Templates بر روی Web Form كليك كنيد.

٣- عنوان صفحه را به Home تغيير دهيد.

٤- زبان مورد نظر خود را در قسمت Language انتخاب كنيد.

٥- Select Master Page را انتخاب كرده و بر روی Add كليك كنيد تا صفحه Select a Master Page ظاهر شود.

٦- حال Master1.master را انتخاب كرده و بر روی ok كليك كنيد.

صفحه home همانند شكل زير به پرو‍ژه اضافه خواهد شد.

همانطور كه مشاهد می كنيد قسمتهای استاتيك كه در Master Page آن را طراحی كرديم، در اينجا بصورت مات ديده می شود. اين بدين معناست كه شما در اين صفحه نمی توانيد آنها را تغيير دهيد.

حال به دلخواه خود المانها و كنترلهای مختلفی را به صفحه home.aspx اضافه كنيد. برای اين منظور بر روی نوار عنوان كنترل ContentPlaceHolder راست كليك كرده و گزينه CreateCustomContent را انتخاب كنيد. حال در كنترل ContentPlaceHolder يك جمله مانند “Welcome to my website” تايپ كرده و حاصل كار را ذخيره كنيد.

صفحه about.aspx را نيز بمانند صفحه home به وب سايت اضافه كنيد.

حال می توانيدحاصل كار خود را با فشار دادن دكمه های Ctrl+F5 مشاهده كنيد.

ASP.NET محتوای صفحات home و about را با Master Page تركيب كرده و به نمايش در می آورد. همان طور كه مشاهده می كنيد در ASP.NET 2 پروژه ها بر روی شماره پورتهای تصادفی در Localhost اجرا می شوند.

مرجع: MSDN

همه مقالات فرم های وب را ببينيد.
جستجو: بگرد!
جستجوی پيشرفته
نام کاربری |
کلمه عبور |


IranASP.NET - لذت برنامه نويسی تحت وب با ASP.NET 2.0: تغيير Master Page ها بصورت پويا

لذت برنامه نويسی تحت وب با ASP.NET 2.0: تغيير Master Page ها بصورت پويا

Shahabfar.com Iranian .NET Community | اين مقاله ۳۴۳۷ بار تاکنون ديده شده است.
۱۳۸۳/۹/۹ | برای وبلاگ برای وبلاگ
در قسمت اول از مجموعه اين مقاله ها آموختيد كه چگونه می توان بوسيله Master Page ها در ASP.NET 2.0 به سادگی طرح بندی های مختلفی را برای فرم های وب ايجاد كرد. تحت شرايطی بعضاً ممكن است به تغيير يك Master Page بصورت پويا نياز پيدا كنيم. مثلاً ممكن است در يك وب سايت برای موضوعات مختلف طرح بندی سايت تغيير كند. اين مقاله را بخوانيد تا روش انجام اين کار را ياد بگيريد.

تحت شرايطی بعضاً ممكن است به تغيير يك Master Page بصورت پويا نياز پيدا كنيم. مثلا" ممكن است در يك وب سايت برای موضوعات مختلف طرح بندی سايت تغيير كند. بديهی است كه برای اين منظور بسته به نيازمان Master Page های مختلفی را در ابتدای كار می بايست ايجاد كنيم. در اين مقاله می آموزيد كه چگونه می توان بصورت پويا يك Master Page را با ديگری جايگزين كرد.

برای اين منظور Master Page دوم را به وب سايتمان كه در قسمت اول مقاله ايجاد كرديم اضافه كرده و يك كنترل button برای سوئيچ كردن بين Master Page ها اضافه می كنيم. از آنجا كه Master Page دوم بسيار شبيه اولی می باشد لذا تنها كافيست يك كپی از آن تهيه كرده و برای تمايز، رنگ پس زمينه آن را تغيير دهيم.

برای اين منظور مراحل زير را دنبال كنيد:

١- در Solution Explorer بر روی Master1.master راست كليك كرده و گزينه كپی را انتخاب كنيد.

٢- بر روی نام وب سايت راست كليك كرده و گزينه paste را انتخاب كنيد.

٣- Master Page كپی شده را به Master2.master تغيير نام دهيد.

٤- فايل Master2.master را در حالت Html باز كرده و در قسمت Master1 ،@Master را به Master2 تغيير دهيد.

Master Language="C#" CompileWith="Master2.master.cs" ClassName="Master2_master@"

٥- به حالت Design View برويد.

٦- در پنجره properties از ليست باز شو كه در قسمت بالای اين پنجره قرار دارد گزينه DOCUMENT را انتخاب كنيد.

۷- مقدار BgColor را به دلخواه تغيير دهيد.

۸- Master Page جديد را در حالت سورس كد باز كنيد و نام كلاس را از Master1_master به Master2_master تغيير دهيد.

برای اضافه كردن يك button جهت تغيير پويا Master Page ها مطابق زير عمل كنيد:

١- يك كنترل از نوع LinkButton به پايين صفحه Master2.master اضافه كرده و برای آن يك نام انتخاب كنيدمثلا" “Change to MP1”

٢- بر روی button دو بار كليك كنيد تا تابع رويداد كليك آن ايجاد شود. سپس كد زير را به آن اضافه كنيد.

void LinkButton1_Click(object sender, EventArgs e)

{

Session("masterpage") = "MasterPage1.master";

Response.Redirect(Request.Url.ToString());

}

كد فوق موجب بار گزاری نام Master Page اول در Session شده و سپس صفحه جاری دوباره فراخوانی می شود.

٣- صفحه Master1.master را باز كنيد و يك كنترل LinkButton مطابق مراحل فوق به آن اضافه كنيد و نوشته روی آن را “Change to MP2” قرار دهيد.

٤- در تابع مربوط به رويداد كليك آن كد زير را اضافه كنيد.

void LinkButton1_Click(object sender, EventArgs e)

{

Session("masterpage") = "MasterPage2.master";

Response.Redirect(Request.Url.ToString());

}

٥- صفحه About.aspx را در حالت سورس كد باز كنيد.

٦- تابع Page_PreInit را اضافه كرده و كد زير را در آن بنويسيد.

كد فوق باعث جايگزين كردن محتويات [Session[“masterpage” با مقدار مشخصه Me.MasterPageFile می شود. اين كار می بايست حتما" در تابع Page_PreInit صورت گيرد. زيرا در يك WebForm قبل از هرگونه مقدار دهی اوليه می بايست تكليف Master Page آن مشخص شود. و بهترين گزينه تابع Page_PreInit می باشد. لذا قرار دادن اين كد در توابعی مثل Page_Init و Page_Load كه بعد از تابع Page_PreInit فراخوانده می شوند، تأثير گذار نخواهد بود.

حال بعد از اعمال مراحل فوق حاصل كار را مطابق زير امحان می كنيم:

١- CTRL+F5 را فشار دهید تا صفحه home در browser نمایان شود.

٢- به صفحه About رفته و بر روی Chage to MP2 کلیک کنید. مشاهده می کنید که صفحه About با Master2.master باز خواهد شد.

٣- بر روی Change to MP1 کلیک کنید. می بینید که اینبار صفحه About با Master1.master باز می شود.

مراحل فوق يك مثال بسيار ساده برای تغيير Master Page ها بصورت پويا را شامل می شدند. امروزه بعضی از وب سايتها مثل MSN.com اين قابليت را برای كاربران عضو مهيا ساخته اند كه بتوانند طرح بندی صفحه مربوط به خود را بصورت پويا براحتی تغيير دهند. مسلماً استفاده از Master Page ها برای اين منظور كار را بسيار ساده و سريع خواهد نمود.

دریافت Web Developer 2005 Express Edition (ASP.NET 2) beta

مرجع: MSDN

همه مقالات فرم های وب را ببينيد.
جستجو: بگرد!
جستجوی پيشرفته
نام کاربری |
کلمه عبور |


IranASP.NET - به رمز درآوردن اطلاعات

به رمز درآوردن اطلاعات

حسین روزنامه چی | اين مقاله ۶۱۸۲ بار تاکنون ديده شده است.
۱۳۸۳/۹/۲۲ | برای وبلاگ برای وبلاگ
تا به حال به این فکر افتاده اید که یک سری اطلاعات را به صورت رمز در آورید و از دید کاربر پنهان کنید؟ برای مثال یک QueryString یا اطلاعات ذخیره شده داخل یک کوکی. گاهی هم بد نیست بعضی از اطلاعات داخل بانک اطلاعاتی خود را به صورت رمز ذخیره کنید تا در صورت سرقت آن، حداقل برخی اطلاعات حساس شما تا حدی محفوظ بماند. در این مقاله سعی میکنیم یک روش استاندارد برای به رمز در آوردن رشته ها را با هم مرور کنیم.

برای اینکه همراه ما پیش بروید در VS.net یک پروژه جدید C# Application به صورت ASP.net Web Application ایجاد کنید. WebForm1.aspx به صورت پیش فرض در مقابل شما قرار میگیرد، از Toolbox یک Label داخل WebForm1 درگ کنید، به صورت پیش فرض نام آن Label1 خواهد بود.

معرفی Base64String

Base64String نوعی از String است (و با خصوصیات یک string معمولی) که کاربر نمیتواند آن را تشخیص دهد، (اگر کسی را میشناسید که میتواند به من هم بگویید!) برای مثال جمله "I LOVE ASP.net"، در Base64String میشود "SSBMT1ZFIEFTUC5uZXQ=". اما چطور؟

string String = "I LOVE ASP.net";
byte [] Byte = System.Text.Encoding.ASCII.GetBytes(String);
Label1.Text = Convert.ToBase64String(Byte);

در خط اول ما یک string معمولی را ساختیم در خط بعدی آن را به byte تبدیل کردیم و Byte نامیدیم، در خط سوم Byte را به صورت Base64String در آوردیم و توسط Label1 به نمایش در آوردیم. فکر خوبی است که عملیات رمز سازی را همین جا تمام کنیم چون Base64String برای کاربر معمولی قابل مشاهده نیست! اما اگر چند خط بالا را با این خط ها عوض کنیم چه میشود؟

string MyBase64String = "SSBMT1ZFIEFTUC5uZXQ=";
byte[] MyByte =Convert.FromBase64String(MyBase64String);
Label1.Text = System.Text.Encoding.ASCII.GetString(MyByte);

حدس بزنید نتیجه چه میشود؟! بله "I LOVE ASP.net"! در حقیقت ما همان راهی را که رفته بودیم برگشتیم! ابتدا Base64String را به byte تبدیل کردیم و سپس byte را به string معمولی. پس اگر برای ما مهم باشد که اطلاعات رمز شده ما برای کسی قابل بازگشت نباشد هنوز کارمان تمام نشده است. حالا که یاد گرفته اید با Base64String کار کنید بگویید:
"VHJ5IHRvIGZpbmQgd2hhdCB5b3UgbmV2ZXIgbG9vc2U= " چیست ؟! من جوابش را پیدا کردم و به صورت رمز در آوردم "jcUKVu8D4dlpy4BHw6bgefaVMWW9x0qV " جواب است ، امتحان کنید آن را به روش قبلی به string تبدیل کنید و ببیند آیا به جواب منطقی می رسید؟ برای رسیدن به جواب اصلی باید بتوانید آن را رمز گشایی کنید!

Cryptography با استفاده از TripleDES و MD5

در بالا با Base64String آشنا شدیم حالا وقت آن است که با یکی از روشهای معمول رمز سازی در دات نت آشنا شویم این روش فقط یکی از روشهای معمول رمزسازی در دات نت است برای آشنایی با روشهای دیگر از MSDN راهنمایی بگیرید . بیایید ابتدا با عبارتهای تازه‌ی این مبحث آشنا شویم:

TripleDES: برای رمز سازی سه بار از الگوریتم DES استفاده میکند.
DES: مخفف Data Encryption Standard.
MD5: یک الگوریتم کار آمد رمز سازی است که در بسیاری از زبانهای برنامه نویسی دیگر نیز و جود دارد. MD5 عضوی با نام ComputeHash دارد که یک تابع Hash یا (Hash function) است.

توابع Hash یا (Hash functions) یک binary string با طول دلخواه را به یک binary string با طول کوتاه و ثابت! تبدیل میکند، و این خاصیت را دارد که هرگز برای دو ورودی مجزا یک خروجی یک یکسان وجود نخواهد داشت (به عبارت دیگر توابع Hash تضمین میکنند که هر ورودی خروجی منحصر به فردی را داشته باشد). خوب برای به رمز در آورن کافی است مانند مثال زیر عمل کنیم (فعلا آن را اجرا نکنید!):

byte[] IV = new byte[8] {240, 32, 45, 29, 0, 76, 173, 59};
string cryptoKey = "All you need is Love";
string MyString = "I LOVE ASP.net";
byte[] buffer = System.Text.Encoding.ASCII.GetBytes(MyString);
TripleDESCryptoServiceProvider des = new TripleDESCryptoServiceProvider();
MD5CryptoServiceProvider MD5 = new MD5CryptoServiceProvider();
des.Key = MD5.ComputeHash(System.Text.ASCIIEncoding.ASCII.GetBytes(cryptoKey));
des.IV = IV;
byte[] CodedBuffer = des.CreateEncryptor().TransformFinalBlock(buffer,0,buffer.Length);
Label1.Text = System.Convert.ToBase64String(CodedBuffer,0,CodedBuffer.Length);

ابتدا بگذارید ببینیم IV و cryptoKey چیستند؟
DESCryptoServiceProvider (و به دنبال آن TripleDESCryptoServiceProvider) دارای یک Key و یک IV مخفف Initialization Vector هستند که برای رمز کردن داده ها از آن استفاده میشود (همان طور که لازم نیست بدانیم کی برد و موس چگونه دستورات ما را به سخت افزار کامپیوتر منتقل میکنند تا از آنها استفاده کنیم، لازم نیست به دنبال این باشیم که Key و IV در DESCryptoServiceProvider دقیقا چگونه کار میکنند فقط کافی است بدانیم از آنها چطور استفاده کنیم). باید توجه داشته باشیم اگر فراموش کنیم IV را مقدار دهی کنیم در هنگام اجرا IV یک مقدار تصادفی خواهد گرفت که برگردان داده های رمز شده را غیر ممکن میکند!

در مثال بالا IV را از جنس byte تعریف کردیم و cryptoKey از جنس string به صورت "All you need is Love" مقدار دهی کردیم که در حقیقت "All you need is Love" کلید رمز ما خواهد بود. MyString همان stringای است که باید به صورت رمز در بیاید. (اگر کمی از #C سر در بیاورید با چند خط بعدی مشکلی نخواهید داشت).

des.Key: حالا وقت آن شده است که Key را مقدار دهی کنیم، اما باید آن را توسط MD5.ComputeHash به صورتی مناسب برای Key بودن تبدیل کنیم و فراموش نکنیم که MD5.ComputeHash، از string به عنوان ورودی نمیتواند استفاده کند و باید قبل از آن cryptoKey خود را به حالت byte تبدیل کرده باشیم (System.Text.ASCIIEncoding.ASCII.GetBytes(cryptoKey)).

و حالا وقت خوبی است تا CreateEncryptor برای رمز سازی اقدام کند و TransformFinalBlock مقدار Hash شده‌ای برای منطقه مشخص شده ای از آرایه های byte مشخص شده حساب میکند. اما توجه داشته باشید که ما byte رمز شده لازم نداریم بلکه string رمز شده میخواهیم پس در قدم آخر باید یک Base64String تولید کنیم.

سوالی که پیش می‌آید این است که TripleDESCryptoServiceProvider و MD5CryptoServiceProvider کجا هستند؟ فضای نام System.Security.Cryptography پاسخ این سوال است پس حالا میتوانید پروژه‌ای را که ایجاد کرده بودیم بیاورید و به جای کد های قبلی کدهای مثال بالا را در آن قرار دهید و فراموش نکنید که namespace جدید را به صورت using System.Security.Cryptography به بالای کدهای خود اضافه کنید.

این روش بر خلاف بعضی از روشهای یک طرفه، قابلیت بازیابی اطلاعات رمز شده را دارا میباشد، فقط کافی است ازCreateDecryptor استفاده کنیم :

byte[] IV = new byte[8] {240, 32, 45, 29, 0, 76, 173, 59};
string cryptoKey = "All you need is Love";
string CodedString64 = "zNvKahC6S/+8xMX3o658wQ==";
byte[] buffer = Convert.FromBase64String(CodedString64);
TripleDESCryptoServiceProvider des = new TripleDESCryptoServiceProvider();
MD5CryptoServiceProvider MD5 = new MD5CryptoServiceProvider();
des.Key = MD5.ComputeHash(System.Text.ASCIIEncoding.ASCII.GetBytes(cryptoKey));
des.IV = IV;
byte[] CodedBuffer = des.CreateDecryptor().TransformFinalBlock(buffer,0,buffer.Length);
Label1.Text = System.Text.Encoding.ASCII.GetString (CodedBuffer);

خوب حالا میتوانید به من بگویید "jcUKVu8D4dlpy4BHw6bgefaVMWW9x0qV " (که همان جواب معمای ما هم بود) چیست ؟ صد در صد خیر! مگر اینکه من به شما IV و Key آن را بگویم! IV مانند مثال و Key نیز "red rose" است! حالا اگر مطالب را دنبال کرده باشد احتمالا به راحتی میتوانید رمزگشایی کنید!

چند نکته امنیتی

آیا این روش، روش قابل اطمینانی است؟ باید بگویم تا وقتی نخواهید اطلاعات چند صد هزار دلاری یا اسناد محرمانه ای را به رمز تبدیل کنید احتمالا میتوانید روی آن حساب کنید مخصوصا که TripleDES سه بار با الگوریتم DES آن را به رمز تبدیل کرده است (سه بار رمز شکستن به راحتی سه بار رمز کردن نیست!).
شما میتوانید برای سخت تر کردن کار رمزشکن از Key های مختلفی استفاده کنید ( البته سعی کنید برای رمز کردن کلمه عبور، نام کاربری یا email را به عنوان کلید رمز قرار ندهید! چون شما جزو اولین 10000 نفری نیستید که این کار را کرده اند!). حفاظت اطلاعات شما در گروی امن بودن server ای است که سایت شما روی آن قرار دارد، همینطور از قرار دادن Key در Web.config به عنوان یک کار خلاقانه! جدا خودداری کنید.

همه مقالات کليات ASP.NET را ببينيد.
جستجو: بگرد!
جستجوی پيشرفته
نام کاربری |
کلمه عبور |


IranASP.NET - ايجاد حالت برگشت برای DataReader

ايجاد حالت برگشت برای DataReader

لطفعلی خوش نفس | اين مقاله ۳۷۸۲ بار تاکنون ديده شده است.
۱۳۸۳/۱۰/۱۶ | برای وبلاگ برای وبلاگ
برنامه نويسان پايگاه داده به خوبی با DataReader و قابليتهای بالای آن در كار با بانكهای اطلاعاتی آشنا هستند. کاربرد DataReader برای خواندن سريع تعدادی رکورد از بانک اطلاعاتی و احتمالا نمايش آنها بر روی صفحه است. خواندن رکوردها توسط DataReader همواره حرکتی رو به جلو (Forward-Only) بوده و نمی توان هنگام استفاده از DataReader به عقب برگشت و به رکوردهای قبلی دسترسی داشت. اين مقاله روشی را ارائه می کند که با استفاده از آن بتوان حرکت رو به عقب هنگام استفاده از DataReader را نيز به گونه ای فراهم آورد.

در اين روش ما موقعيت فعلی DataReader را ذخيره می كنيم و برای برگشت به ركورد قبلی از ابتدا تا يكی مانده به ركورد فعلی ركوردها را پيمايش می كنيم و در پايان آخرين ركورد پيمايش را به كاربر نشان می دهيم برای اين كار به صورت زير متغيرهايی عمومی تعريف می نماييم:

Dim Index as Integer
Dim IndexTemp as Integer
Dim Dr as OleDb.OleDbDataReader

منظور از متغير عمومی در عبارت بالا متغيری در محدوده يك فرم يا يك كلاس و... كه DataReader در آن استفاده می شود می باشد. سپس سه تابع يا سابروتين (بسته به نحوه استفاده) تعريف می نماييم:

Private Sub GetData()
Dim Cmd as New OleDb.OleDbCommand("Select ID From TblSample")
Dr=Cmd.ExecuteReader
Index=0
End Sub

سابروتين بالا برای خواندن ركورد از يك جدول فرضی می باشد.

Private Sub Next ()
Dr.Read
Index+=1
IndexTemp=Index
ShowData ()
End Sub

سابروتين بالا برای حركت به ركورد بعدی می باشد.

Private Sub Back()
Dim I as Integer
Me.GetData()
For I=0 To IndexTemp-2
Dr.Read
Next
Index=I
IndexTemp=Index
ShowData ()
End Sub

سابروتين بالا برای حركت به ركورد قبلی می باشد. لازم به ذكر است كه كدهای بالا به صورت شبه كد می باشند و هدف فقط نشان دادن نحوه انجام كار می باشد. شايد برخی دوستان با ديدن اين مقاله به اين فكر بيفتند كه به جای اين كار ميتوان از DataSetاستفاده كرد كه لزومی به اين همه دردسر ندارد ولی بر حسب تجربه اعلام می كنم كه در برخی مواقع مجبور به استفاده از DataReader خواهيد شد، برای نمونه در يكی از برنامه هايی كه برای يكی از موسسات نوشته بودم قسمتی وجود داشت كه تصاوير مربوط به قسمتهای مختلف موسسه را در بانك ذخيره می كرد و در موقع لزوم تصاوير مورد نظر با توجه به نام قسمت مربوطه فرخوانی می شدند برای اين كار اگر از DataSet استفاده شود به دليل اينكه DataSet ركوردها را در حافظه نگهداری می كند و با توجه به حجم بالای حافظه مورد نياز برای نگهداری تصوير با بالا رفتن ركوردها حافظه بلافاصله پر می شود، ولی DataReader تك ركورد را در حافظه نگهداری می كند و با توجه به مديريت حافظه خودكار در .Net با حركت در بين تصاوير حافظه تخصيص داده شده به تصوير قبلی بازپس گرفته می شود.

همه مقالات ADO.NET و پايگاه داده را ببينيد.
جستجو: بگرد!
جستجوی پيشرفته
نام کاربری |
کلمه عبور |


IranASP.NET - جستجوی نام های دامنه (Whois) در ASP.NET

جستجوی نام های دامنه (Whois) در ASP.NET

احسان صادقی | اين مقاله ۲۷۵۹ بار تاکنون ديده شده است.
۱۳۸۳/۱۲/۳ | برای وبلاگ برای وبلاگ
اگر به سایتهای ثبت دامنه مانند www.Register.com سر زده باشید، دیده اید که این سایتها امکاناتی برای جستجوی نام دامنه در اختیار شما می گذارند که به شما وجود یا عدم وجود آن نام را اطلاع می دهند و اطلاعاتی نیز درباره فرد یا سازمان صاحب نام می دهد. در این مقاله نحوه ی انجام این کار را با ASP.NET شرح می دهیم.

برای انجام عمل جستجو ابتدا باید یک ارتباط با سرورهایی که بانکهای اطلاعاتی آنها این مشخصات را دارند ارتباط برقرار کرد و با یک Query، اطلاعات مورد نظر را درخواست نمود. این ارتباط از نوع TCP و از طریق پورت 43 انجام می گیرد. لیست کاملی از این سرورها را اینجا می توانید ببینید.

مشخص کردن فضا نامها
ابتدا فضا نامهای مورد نیاز را مشخص می کنیم:

Using System.Net.Sockets;
Using System.Text;
Using System.IO
Using System.Text.RegularExpressions;

با استفاده از TcpClient در NetFramework. می توانیم این ارتباط را با سرور مورد نظر برقرار نماییم. برای استفاده از این کلاس باید فضانام System.Net.Sockets را وارد کنیم. از دو فضانام دیگر نیز برای فرمت ورودی و خروجی خود استفاده می کنیم.

ایجاد و ارسال Query
ابتدا متغیرهای مورد نیاز را تعریف می کنیم:

string StrSvr,StrDomain, Resp;
TcpClient TcpClt;
byte[] ArrDomain;
Stream TcpStr;
StreamReader TcpStrRdr;

حال باید رشته ای را که می خواهیم به عنوان Query به سرور ارسال نماییم، ایجاد کنیم. برای این کار باید نام درخواستی کاربر را همراه پسوند مورد نظر(Com ،Org،...) را به سرور ارسال نماییم. توجه داشته باشید که هر کدام از سرورهای موجود در لیست فوق الذکر برای جستجوی پسوند خاصی می باشد. برای مثال whois.internic.com تنها برای دامنه های net. و com. و edu. می باشد و اگر دامنه ای با پسوند Info. را با این سرور جستجو نمایید، جواب مطلوب را نخواهید گرفت.

بنابراین ابتدا باید پسوند مورد نظر کاربر و سپس سرور مربوطه را مشخص نماییم . در اینجا برای انتخاب پسوند از DropDownList استفاده کرده ام:

if (DDLstSuffix.SelectedItem.Value == ".COM" || DDLstSuffix.SelectedItem.Value == ".NET" || DDLstSuffix.SelectedItem.Value == ".EDU")
{
StrSvr = "whois.internic.net";
StrDomain = TxtDomainName.Text.Trim() + DDLstSuffix.SelectedItem.Value+ "\r\n";
}
else if (DDLstSuffix.SelectedItem.Value == ".ORG")
{
StrSvr = "whois.publicinterestregistry.net";
StrDomain = TxtDomainName.Text.Trim() + DDLstSuffix.SelectedItem.Value+ "\r\n";
}
else if (DDLstSuffix.SelectedItem.Value == ".BIZ")
{
StrSvr = "whois.neulevel.biz";
StrDomain = TxtDomainName.Text.Trim() + DDLstSuffix.SelectedItem.Value+ "\r\n";
}
else if (DDLstSuffix.SelectedItem.Value == ".INFO")
{
StrSvr = "whois.afilias.info";
StrDomain = TxtDomainName.Text.Trim() + DDLstSuffix.SelectedItem.Value+ "\r\n";
}
else if ((DDLstSuffix.SelectedItem.Value == ".IR") || (DDLstSuffix.SelectedItem.Value == ".CO.IR") || (DDLstSuffix.SelectedItem.Value == ".NET.IR") || (DDLstSuffix.SelectedItem.Value == "ID.IR"))
{
StrSvr = "whois.nic.ir";
StrDomain = TxtDomainName.Text.Trim() + DDLstSuffix.SelectedItem.Value+ "\r\n";
}

همانطور که می بینید، رشته ای که برای جستجو ارسال می شود به "r\n\" ختم می شود. اگر این رشته را در انتهای نام دامنه قرار ندهید، سرور نمی تواند جواب مطلوب را برگرداند.

اتصال به سرور
حال یک ارتباط باید با سرور مورد نظر برقرار نماییم. کلاس TcpClient، متدهایی برای اتصال، دریافت و ارسال اطلاعات دارد. به دو صورت می توانیم با یک سرور ارتباط برقرار کنیم:

1 – ایجاد یک نمونه از کلاس TcpClient بدون هیچ پارامتری و سپس استفاده از متد Connect:

TcpClient TcpClt = new TcpClient();
TcpClt.Connect(StrSvr,43);

2 – ایجاد یک نمونه از کلاس TcpClient با پارامترهای آدرس سرور و پورت مقصد که می خواهید با آن ارتباط برقرار کنید. این Constructor ارتباط را به صورت اتوماتیک ایجاد می کند:

TcpClient objTCPC = new TcpClient(StrSvr, 43);

پس از آن با متد GetBytes کلاس Encoding (فضا نام System.Text) رشته StrDomain را به یک آرایه از نوع بایت می نویسیم.

ArrDomain = Encoding.ASCII.GetBytes(strDomain);

با استفاده از متد GetStream کلاس TcpClient ، یک Stream ایجاد می کنیم و از طریق آن به ارسال و دریافت اطلاعات می پردازیم:

TcpStr = TcpClt.GetStream();

با استفاده از این Stream می توانیم با متد Write یک آرایه از Byte را در Stream جاری نوشت :

TcpStr.Write (ArrDomain,0,StrDomain.Length);

دریافت و نمایش نتیجه جستجو
یکی از راههای دریافت اطلاعات از سرور، ایجاد یک نمونه از کلاس StreamReader و سپس خواندن اطلاعات بر اساس یک Encoding مشخص می باشد.

TcpStrRdr = new StreamReader(TcpClt.GetStream(),Encoding.ASCII);

قدم بعد، استفاده از متد ReadToEnd برای دریافت جواب سرور می باشد. این رشته شامل کاراکترهای خط جدید "n\" می باشد که باید با "<br>" جایگزین شود. برای این کار از متد Replace کلاس RegEx استفاده می کنیم ، سپس برای راحتی جستجو این رشته را به حروف کوچک تبدیل می کنیم :

Resp = Regex.Replace(TcpStrRdr.ReadToEnd(),"\n","<br>");
Resp = Resp.ToLower();

اگر در این رشته، زیر رشته هایی مانند "no match" يا "not found" یا "no entries found" وجود داشته باشد، نام دامنه مورد نظر آزاد می باشد. در غیر اینصورت آن دامنه ثبت شده است. حال با استفاده از این مساله، نتیجه را به کاربر اعلام می کنیم. برای جستجوی این زیر رشته ها از متد IsMatch کلاس RegEx استفاده می کنیم. اگر در این متد زیر رشته مورد نظر در رشته موجود باشد True و در غیر اینصورت False برگشت داده می شود.

if (Regex.IsMatch(Resp,"no match") || Regex.IsMatch(Resp,"not found") || Regex.IsMatch(Resp,"no entries found"))
{
SearchRes = " دامنه مورد نظر موجود مي باشد ";
PnlOrder.Visible = true;
PnlOrderOk.Visible = false;
}
else
{
SearchRes = " دامنه مورد نظر موجود نمي باشد ";
PnlOrder.Visible = false;
PnlOrderOk.Visible = false;
}

در انتها نیز ارتباط را می بندیم.

TcpClt.Close();

منبع: Build a WHOIS Lookup in ASP.NET

همه مقالات کليات ASP.NET را ببينيد.
جستجو: بگرد!
جستجوی پيشرفته
نام کاربری |
کلمه عبور |


IranASP.NET - کلاس درس را به خانه ببرید، گفتگو با مهندس مانی قاسم نیا همدانی مبتکر و تهيه کننده «کتاب گويا»

کلاس درس را به خانه ببرید، گفتگو با مهندس مانی قاسم نیا همدانی مبتکر و تهيه کننده «کتاب گويا»

مديريت سايت | اين مقاله ۳۹۸۱ بار تاکنون ديده شده است.
۱۳۸۳/۱۲/۱۳ | برای وبلاگ برای وبلاگ
مؤسسه انتشارات کتاب های ارغوانی با همکاری شرکت نرم افزاری ساین تک اخیرا فعالیت نوینی را در راستای توسعه و ترویج آموزش الکترونیک آغاز نموده و اولین اثر خود را با عنوان «کتاب گویا» در زمینه Visual C# .Net که اولین مبحث در زمینه اصول برنامه نویسی NET. می باشد منتشر کرده است. توضیحات بیشتر در این زمینه را از زبان آقای مهندس مانی قاسم نیا همدانی مدیر فنی انتشارات کتاب های ارغوانی که طراح و مدرس این سبک نوین آموزشی می باشد می خوانیم.

۱- ممکن است درباره کتاب گویا و سبک آموزشی آن توضیح دهید؟
اولا از حسن توجه شما به کتاب گویا که یک نوآوری در امرنگارش و آموزش است بسیار سپاسگزارم. ثانیا لازم است به این نکته اشاره کنم که تهیه این نوع کتاب برای من که سالهاست به کار تالیف و ترجمه اشتغال دارم به مراتب دشوارتر، وقت‌گیرتر و گران‌تر از یک نگارش ساده بوده و توجه شما برای من بسیار ارزشمند و باعث تشکراست. امیدوارم بقیه وب سایت های فرهنگی و آموزشی هم که به نوعی پاسدار علم و تخصص اند مثل شما به این ابتکار توجه ویژه مبذول نمایند تا برای کسانی که به هرشکل فعالیت های فرهنگی دارند مشوق و راهگشا باشند.

بحث آموزش الکترونیکی و سیستم های آموزش از راه دور، مدتی است که در کشور ما مطرح شده ولی تا کنون فعالیت اساسی و چشمگیری در این زمینه صورت نگرفته است. من با توجه به این که در کار تدریس و تالیف دوره های IT و اصول برنامه نویسی کامپیوتر یک دهه فعالیت و تجربه داشتم تصمیم گرفتم کلاسهای درسم را به صورت ویدئویی درآورم و در اختیار علاقمندان قرار دهم تا به سهم خودم گامی جدی در جهت ترویج آموزش الکترونیکی برداشته باشم.

۲- ولی تهیه کتاب بصورت ویدیویی بسیار مشکل و گران است؛ چرا از روشهای ساده تر مثل e-Book برای اینکار استفاده نکردید؟
ببینید، اولا از لحاظ روانی وقتی دانشجو مدرس را ببیند و بشناسد و با او ارتباط برقرار کند فهم و هضم مطالب برایش خیلی آسان می شود. ثانیا تهران شهر بزرگی است؛ باترافیک سنگین وخسته کننده، شرکت در کلاس های حضوری هم صرف نظر از هزینه زیاد به اتلاف وقت و خستگی زیاد دانشجو منجر می‌شود. به همین خاطر کلاس درس را بطور کامل به شکل ویدئویی درآوردم و منطبق با سرفصل‌های کتاب تدریس کردم تا هم صورت کتاب داشته باشد و هم شکل کلاس و نام کتاب گویا را هم برای آن انتخاب کردم و به همین نام به ثبت رساندم. دراین سیستم دانشجو احساس حضور در کلاس دارد یا به عبارتی کلاس درس را به خانه می‌برد. چیزی شبیه به اینکه معلم خصوصی دارد با این امتیاز که هر مطلب و هر نکته را هر چند بار که نیاز دارد می‌بیند و مستقیما از زبان مدرس می شنود. ضمن این که می‌تواند با مدرس در تماس باشد و سؤالات و اشکالات خود را مطرح نماید. درواقع با این روش کلاس و مدرس مثل کتاب همواره در اختیار دانشجو خواهد بود. تصور میکنم این بهترین و مناسبترین شیوه یادگیری باشد که E-learning را به مفهوم واقعی عرضه می کند. دیگه از این بهتر و کاملتر و ساده تر نمیشه. میشه؟؟؟

۳- شما به E-Learning اشاره داشتید لطفا دراین مورد بیشتر توضیح بدهید؟
منظور از E-Learning یا آموزش الکترونیکی، بطور کلی بهره گیری از سیستم های الکترونیکی، مثل کامپیوتر، اینترنت، CD های Multimedia و نظایر این هاست با هدف کاستن از رفت و آمدها و صرفه جویی در وقت و هزینه و ضمنا یادگیری بهتر و آسانتر.

البته سیستم هایی که E-learning به حساب می‌آیند و امکان یادگیری از راه دور را فراهم می کنند متنوع هستند. ولی در وهله اول آنچه که مهم است آگاهی علاقمندان از نوع این سیستم ها وانتخاب صحیح و نحوه استفاده درست از آنها است. این سیستم ها بعضا میتوانند جایگزین کلاس های حضوری هم باشند. درعین حال برای افراد سخت کوش و علاقمند میتواند مکمل کتاب و کلاس باشد.

۴- ویژگی سیستمی که شما عرضه کرده اید چیست؟

به طور کلی، سیستم های آموزش الکترونیکی به شیوه های مختلفی قابل پیاده سازی هستند. آنچه که ما عرضه کرده ایم به تایید متخصصین و دست اندرکاران از نظر طراحی و سبک آموزش و امکان ارتباط با مدرس، در ایران بی سابقه است. ویژگی مهم این سبک آموزش، سیستم پشتیبانی آن است که دانشجو را به سه روش مورد حمایت قرار میدهد. ما این سبک را به عنوان یک ابتکار مطرح میکنیم. بله، ما مدعی ابتکار عمل در امر آموزش در ایران هستیم. داوری با شما... ببینید و قضاوت کنید!

از متولیان فرهنگ و آموزش این مرز و بوم هم انتظارداریم که ببینند و داوری کنند و اگرحق با ما بود تشویق‌مان کنند تا راه را دنبال کنیم. من یقین دارم چنانچه هرمتقاضی فقط چند دقیقه از این کار را ببیند درانتخاب و ابتیاع آن تردید نمی کند.

۵- به سیستم پشتیبانی اشاره کردید؛ منظورتان ازسیستم پشتیبانی چیست؟
پیش از این نیز به CD های آموزشی اشاره کردم که از جایگاه ویژه ای برخوردار هستند و کاربرد آنها نیز برای همه شناخته شده است. ما سعی کردیم سیستمی پیاده کنیم که نقطه ضعف های پیشین را نداشته باشد. شما میدانید که ظریفترین نکته درامر آموزش امکان رویارویی و ارتباط مستقیم دانشجو با مدرس است که درکتاب گویا تکیه ما هم دقیقا روی همین نکته بوده است. دانشجو با خريد کتاب گویا در حقیقت در کلاس درس ما ثبت نام می‌کند. طی مراحل ثبت نام هم بسیار ساده است. دانشجو از طریق اینترنت و با اعلام شماره سریال کتاب گویا کد ثبت نام خود را دریافت می کند و از آن لحظه به بعد به عنوان دانشجوی این موسسه با مدرس مرتبط می‌شود و میتواند هرگونه سوال درسی را به مدرس ایمیل کند و پاسخ خود را با تلفن یا ایمیل دریافت کند. ضمن اینکه سایت تخصصی ما www.dotnetexperts.net با مقالات و کتابهای درسی فراوان بعنوان یک مرجع راهنمای خوبی برای دانشجویان این رشته است. کلاسهای رفع اشکال ما هم یکی دیگر از امکانات پشتیبانی کتاب گویاست.

۶- لطفا راجع به عنوان این کتاب گویا هم توضیح بدهید؟

با توجه به این که هدف اول ما آموزش دوره های برنامه نویسی NET. بوده، بهتر دیدیم که کار را از #C آغاز کنیم. بنابراین در اولین عنوان کلیه مباحث زبان برنامه نویسی #C را در 22 فصل طراحی و تدوین کردیم و در حال حاضر 10 فصل اول آن تحت عنوان کتاب گویا پکیج شماره 1 آماده عرضه است. این پکیج حاوی 6 عدد DVD است که هر DVD دو فصل یا دو جلسه از کلاس را شامل می‌شود. ضمن این که برای این پکیج از خانه کتاب شابک دریافت شده و اطلاعات آن نیز در کتابخانه ملی ایران ثبت شده است. نکته مهم این که این اولین پکیج ویدئویی در ایران است که موفق به کسب شابک (ISBN) شده است.

پکیج دوم نیز مراحل فیلم‌برداری و تدوین را پشت سر گذاشته و به زودی عرضه خواهد شد. لازم است توضیح بدهم که مطالب مطرح شده در این دوره صرفا مباحث اصلی زبان برنامه نویسی #C را در بر می گیرند؛ بحث Windows Programming یا Web Programming یا امکانات ویژوال زبان #C در این دوره مطرح نشده وبرای هریک از این مباحث و سایر مباحث مربوطه نظیر برنامه نویسی با زبان های C و ++C و UML و طراحی سیستمهای Object-Oriented و بقیه مطالب قرار است پکیج های جداگانه تهیه کنیم.

۷- اهداف و برنامه های آینده خودتان را هم بیان کنید؟

همانطور که اشاره کردم، چون کار خود را با تکنولوژی NET. آغاز کرده ایم تصمیم داریم همه شاخه های این تکنولوژی را به همین صورت تالیف و تدوین کنیم و برای هرمبحث کتاب گویای جداگانه‌ای عرضه نماییم. البته صدور کتاب های گویا به کشورهای فارسی زبان منطقه هم از اهداف بلند مدت ماست که اگر سازمانها و مراکز فرهنگی دولتی حمایتمان کنند اینکار را با جدیت و با عزم راسخ دنبال خواهیم کرد.

علاوه بر این، تصمیم دارم کتاب های آینده خود را به صورت E-Book منتشر کنم تا فرهنگ استفاده از این نوع کتاب نیز به تدریج در جامعه ما رواج پیدا کند.

۸- بهتراست کمی هم درباره خودتان صحبت کنید تا مخاطبانتان آشنایی لازم را با شما پیدا کنند؟

فارغ التحصیل دانشگاه صنعتی امیرکبیر در رشته مهندسی هوافضا هستم. از سال 1367 با برنامه نویسی کامپیوتر آشنا شدم و با توجه به علاقه زیادی که به این رشته داشتم، مطالعات خود را تا به امروز ادامه دادم و حاصل آن کسب تخصص در برنامه نویسی Windows و اخذ مدرک در همین زمینه از شرکت Microsoft است.

تا بحال 16 عنوان کتاب در زمینه های مختلف IT از جمله برنامه نویسی NET. تالیف و ترجمه کرده ام؛ 13 عنوان از این کتاب ها توسط انتشارات ناقوس به چاپ رسیده، اثر چهاردهم همین کتاب گویا (پکیج ویدئویی #C) است که توسط انتشارات کتاب های ارغوانی منتشر شده، و دو کتاب دیگر هم آماده چاپ دارم که یکی از آنها مرجع کامل زبان برنامه نویسی #C است. همانطور که پیش از این نیز اشاره کردم، تصمیم دارم این دو کتاب را به صورت E-Book منتشر کنم.

۹- در پایان اگر صحبت دیگری دارید مطرح کنید.
صحبت دیگری نیست جز این که باز هم از لطف شما و توجهی که به این فعالیت داشتید تشکر و سپاسگزاری کنم. امیدوارم با یاری و حمایت های شما و علاقمندان به اين رشته در آینده نزدیک بتوانم بقیه پکیج های مربوط به برنامه نویسی NET. را نیز آماده کنم و در اختیار علاقمندان قرار دهم.

همه مقالات گفتگو را ببينيد.
جستجو: بگرد!
جستجوی پيشرفته
نام کاربری |
کلمه عبور |


IranASP.NET - صدا زدن رويدادهای User Control از داخل فرم‌های وب

صدا زدن رويدادهای User Control از داخل فرم‌های وب

Shahabfar.com Iranian .NET Community | اين مقاله ۲۴۹۱ بار تاکنون ديده شده است.
۱۳۸۳/۱۲/۲۳ | برای وبلاگ برای وبلاگ دريافت کد
استفاده از کنترل‌های کاربری يا User Control در ميان برنامه نويسان ASP.NET طرفداران زيادی دارد. با استفاده از UC می توان مجموعه ای از کنترلهای سمت سرور يا html را در جاهای مختلف از صفحات aspx يا داخل UCهای ديگر استفاده کرده و از نوشتن کدهای تکراری اجتناب نمود. در بسياری از موارد لازم می‌شود که بتوانيم رويدادی که درون يک UC اتفاق می‌افتد را در وب فرم مادر اصطلاحاً Handle کنيم. اين مقاله به نحوه چگونگی انجام اين کار می‌پردازد.

استفاده از کنترل‌های کابری UCها (User Control) در ميان برنامه نويسانASP.NET طرفداران زيادی دارد. با استفاده از UC می توان مجموعه ای از کنترلهای سمت سرور يا html را در جاهای مختلف از صفحات aspx يا داخل UCهای ديگر استفاده کرده و از نوشتن کدهای تکراری اجتناب نمود. همچنين می توان تنها قسمتی از يک Web Form را با کمک UCها Cache نمود (Fragment Caching). يکی ديگر از استفاده‌های UCها بکارگيری آنها بعنوان يک کنترل سمت سرور می باشد. که در اين صورت می توان برای UC مورد نظر Methodها و Propertyهای مختلفی را بسته به نياز تعريف کرده و از آنها استفاده نمود. آن دسته از توابعی که اکثر کنترلهای سمت سرور از آن برخوردار می باشند، توابع رويداد يا همان Eventها می باشند. مثل تابع رويداد فشردن يک کنترل از نوع Button.

اکنون می خواهيم بدانيم که در UCها چگونه می توان توابع رويداد تعريف کرده و از آنها استفاده نمود. به دو طريق می توان برای يک UC تابع رويداد تعريف کرد. روش اول تعريف يک تابع رويداد داخلی برای يک UC می باشد. که در اين صورت تابع رويداد تنها در داخل UC صدا زده می‌شود. اما روش دوم تعريف توابع رويداد خارجی است به طوريکه بتوان اين توابع را از خارج UC نيز صدا زد. بحث اصلی اين مقاله پيرامون همين نوع از توابع رويداد يا Event می باشد.

برای درک بهتر مطلب بهتر است که به طرح يک مثال بپردازيم. فرض کنيد که می خواهيد يک کنترل که عملکرد يک منو را داشته باشد با استفاده از UC ايجاد کنيد. اين منو دارای آيتم‌های مختلفی است که هر آيتم نيز ايندکس خاص خود را دارد. حال می خواهيم يک Event برای اين منو تعريف کنيم بطوريکه بتوانيم آن را از همان جايی که UC را استفاده می کنيم، صدا بزنيم. برای ايجاد اين کنترل قبل از هر چيز بهتر است که از يک سرور کنترل تکرار شونده و داده پذير (Data Bound) مثل Repeater ، DataList و يا DataGrid استفاده کنيم. در اين مقاله ما از کنترل DataList استفاده می کنيم.

فرض را بر آن می گيريم که خوانندگان اين مقاله با نحوه استفاده از کنترل DataList آشنايی دارند. لذا بيشتر به توضيح کدهای مربوط به اضافه کردن تابع رويداد خارجی می پردازيم.

بسيار خوب، در ابتدا در کلاس مربوط به UC منو، يک کلاس مثلاً بنام SelectionChangedEventArgs تعريف می کنيم. اين کلاس می بايست حتماً از کلاس System.EventArgs ارث بری داشته باشد. فعلاً برای اين کلاس يک متغير که نشان دهنده ايندکس انتخاب شده از منو می باشد را تعريف می کنيم. بعداً شما می‌توانيد متغيرها و متدهای مورد نظر خود را به اين کلاس اضافه کنيد. پس تا اينجای کار کلاسی همانند زير در داخل کلاس مربوط به UC منو داريم.

public class SelectionChangedEventArgs : EventArgs
{
public int SelectedIndex;
}

برای تعريف تابع رويداد، نيار به يک تابع delegate داريم. اين تابع delegate را می توان با استفاده از کلاسی که در بالا تعريف کرديم بسازيم. کد مربوط به تعريف تابع delegate و تابع رويداد به شکل زير می باشد.

public delegate void SelectionChangedEventHandler(object sender, SelectionChangedEventArgs e);
public event SelectionChangedEventHandler SelectionChanged;

برای تحقق يافتن اين خواسته‌مان نياز به يک تابع رويداد داخلی نيز داريم. از آنجا که هدف ما مشخص کردن انتخاب آيتم های کنترل منو می باشد، پس می بايست که تابع رويداد مربوط به تغيير ايندکس انتخاب شده را برای کنترل DataList موجود در UC را اضافه کنيم. پس از انجام اين کار نوبت به تعريف تابع اصلی مان می‌رسد. يعنی تابعی که در آن مقدمات مربوط به صدا زدن Event خارجی صورت گيرد. اين تابع را بصورت زير تعريف می کنيم.

public void SelectMenuItem(int index)
{
dlMenu.DataBind();
SelectionChangedEventArgs ev = new SelectionChangedEventArgs();
ev.SelectedIndex = index;
if(SelectionChanged != null)
SelectionChanged(this, ev);
}

همانطور که می‌بينيد در اين تابع ابتدا کنترل DataList تغذيه می‌شود. سپس يک نمونه از کلاسی که چندی قبل تعريف کرديم ايجاد می‌شود و تنها عضو اين کلاس که مشخص کننده ايندکس انتخاب شده می باشد توسط تنها پارامتر اين تابع مقداردهی می‌شود. پس از آن در صورت null نبودن تابع رويداد SelectionChanged که مربوط به تابع SelectionChangedEventHandler که خود يک delegate می‌باشد صدا زده می‌شود. اين کار باعث می‌شود تا تابع رويدادی که برای اين کنترل منو در هرکجا تعريف کرده‌ايم، صدا زده شود.

مثالی که به همراه اين مقاله قابل دانلود می باشد شما را با جزئيات کار بيشتر آشنا می کند.

همه مقالات فرم های وب را ببينيد.
جستجو: بگرد!
جستجوی پيشرفته
نام کاربری |
کلمه عبور |


IranASP.NET - جلوگيری از دزدیده شدن محتویات وب سایت

جلوگيری از دزدیده شدن محتویات وب سایت

Amin Roudaky | اين مقاله ۳۹۸۸ بار تاکنون ديده شده است.
۱۳۸۴/۱/۱۵ | برای وبلاگ برای وبلاگ
موضوع اين مقاله کلیه فایلهای موجود در سایت از قبیل JPG ،DOC ،PDF... می‌باشد. اگر از فایلهای خود محافظت نکنید به راحتی هر کسی میتواند به آنها دسترسی پیدا کند چون فقط کافیست از URL آن مطلع شود تا به راحتی بتواند آن را دانلود کند و یا با استفاده از یک Spider کل اطلاعات سایت شما را دریافت کند همانطور که مدتهاست گوگل در حال انجام اینکار است و کلیه تصاویر موجود در هر سایت را ذخیره می کند. خوب راه حل جلوگیری از اینکار چیست؟

هر نوع اطلاعاتی که بتوان فقط با یک URL به آن دسترسی پیدا کرد دیگر مال همه است و همه میتوانند به آن دسترسی داشته باشند و سایتهایی مثل گوگل در ظرف چند دقیقه کل اطلاعات شما را به این صورت دریافت میکنند.

بعضی اوقات شما دوست ندارید همه به اطلاعات شما دسترسی داشته باشند و میخواهید فقط به بعضی افراد اجازه دسترسی به بعضی از فایلها را بدهید خوب به نظر شما راه حل چیست؟ اگر فقط یک سیستم مدیریت کاربر بگذارید و کاربران پس از ورود به آن URL خاص دسترسی پیدا کنند خیلی جالب نخواهد بود زیرا فقط کافیست آن آدرس URL لو رود تا مجددا افراد بدون مجوز بتوانند به آن دسترسی پیدا کنند. پس عملا Authentication ساده ASP.net قادر به امن کردن فایلهای شما نیست و شما باید تدابیر دیگری بیاندیشید.

حتی در مورد این فکر نکنید مثلا اسم فایل را بگذارید 32sdf43ef45.pdf چون این کار ابلهانه‌ای است و در اصل مسئله تفاوتی ایجاد نمی کند. یک Spider و یا یک Hacker خوب میتواند به راحتی به فایلهای شما دسترسی پیدا کند.

راه حل در استفاده از HttpHandler است.

مروری بر HttpHandler
HttpHandler شامل یکسری API هایی جهت انجام امور اشیاء Request/Response که با استفاده از آن میتوانید انتقال اطلاعات را کنترل کنید. در اینجا ما باید یک Handler ایجاد کنید که در زمانی که کسی درخواست یک فایل مثلا doc. میدهد اجرا شود.

خوب بهتر است مقداری کد نویسی کنیم تا بهتر موضوع مشخص شود و متوجه شوید چطور میتوان در یک سایت E-Commerce اطلاعات را امن کرد بدون استفاده از تکنیک های FTP و نیاز به مرورگرهای خاص.

تغییر Web.Config
مرحله اول: باید تگ زیر را در web.config موجود در فولدری که میخواهید آن را Secure کنید وارد کنید.

<HttpHandlers>
<add verb="*" path="*.doc" type="pdfIntercept.pdfHandler, pdfInterceptX" />
</HttpHandlers>

با اینکار در واقع به IHttpHandler میگوئیم که ما میخواهیم درخواستهایی که آخر آنها doc است را کنترل کنیم.

مشخصه verb میتواند حالتهای POST یا GET یا HEAD داشته باشد که در اینجا ما نوشته ایم * یعنی تمامی حالتهای تقاضا را مورد پوشش قرار می دهد.

مشخصه Path در واقع آدرسی که باید مورد بررسی قرار گیرد که با نوشتن doc.* گفته ایم کلیه آدرس های منتهی به doc

مشخصه Type در واقع کلاس دات نت است که باید تقاضا را Handle کند. باید نام کامل کلاس را به صورت زیر بنویسیم.

[NAMESPACE].[CLASS], [ASSEMBLY NAME]

اضافه کردن یک پسوند دلخواه Custom Extension
باید توجه کرد که باید پسوند مورد نیاز را در IIS هم اضافه کنیم. درضمن سپس تنظیمات دایراکتوری محتوی فایلها را به صورت زیر انجام دهید:

Read : False
Write: False
Directory Browsing: False

حال IIS Manager را اجرا کنید و سپس Properties/Edit… را انتخاب کنید آنگاه به بخش Home بروید و دکمه Configuration را بزنید. سپس باید پسوند مورد نیاز خود مثلا doc, pdf را در صفحه تنظیمات نرم افزار اضافه کنید. برروی دکمه add بزنید و اطلاعات مورد نیاز را پر کنید کار بسیار ساده ای است.

بعد از اینکه اینکارها را کرده اید حال آماده هستید تا کد مربوط به HttpHandler را بنویسید.

کد HttpHandler
در زیر کد مربوط به HttpHandler ارائه شده است. البته شما خود باید کد مربوط به Authentication مربوط به سایت خود را در آن قرار دهید.

using System;
using System.Web;
using System.IO;

namespace pdfIntercept
{

public class pdfHandler : IHttpHandler
{

//Notice ProcessRequest is the only method
//exposed by the IHttpHandler
public void ProcessRequest(HttpContext context)
{
try
{
string strString = "yes";
HttpRequest oRequest = context.Request;
HttpResponse oResponse = context.Response;

//ADD YOUR CUSTOM AUTHENICATION HERE
//ADD YOUR CUSTOM AUTHENICATION HERE
//ADD YOUR CUSTOM AUTHENICATION HERE
//ADD YOUR CUSTOM AUTHENICATION HERE

if (strString == "yes")
{

//Since they've made it this far, they've been validated
//by your system…
//We'll fire up a FileStream object
FileStream MyFileStream;
long FileSize;

//Map the path to the .doc file
//You might need to parse out the Request path to figure out
//what resource they're actually requesting…
string strMapPath = context.Server.MapPath("book1.doc");
MyFileStream = new FileStream(strMapPath, FileMode.Open);
FileSize = MyFileStream.Length;

//Allocate size for our buffer array
byte[] Buffer = new byte[(int)FileSize];
MyFileStream.Read(Buffer, 0, (int)FileSize);
MyFileStream.Close();

//Do buffer cleanup
context.Response.Buffer = true;
context.Response.Clear();

//Add the appropriate headers
context.Response.AddHeader("content-disposition",
"attachement filename=x.doc");

//Add the right contenttype
context.Response.ContentType = "application/doc";

//Stream it out via a Binary Write
context.Response.BinaryWrite(Buffer);
}
else
{

//It's a bogus request and they weren't validated.
context.Response.Write("<b>DENIED</b>");
}
}
catch (System.Exception err)
{
err.ToString();
}
}

//By calling IsReusable, an HTTP factory can query a handler to
//determine whether the same instance can be used to service
//multiple requests
public bool IsReusable
{
get
{
return false;
}
}
}

}

اگر میخواهید پیچیدگی مربوط به binary stream را کم کنید میتوانید از متد Response.WriteFile به صورت زیر استفاده کنید.

if (strString == "yes")
{
context.Response.Buffer = true;
context.Response.Clear();
context.Response.AddHeader("content-disposition",
"attachement; filename=x.doc");
context.Response.ContentType = "application/doc";
context.Response.WriteFile("pp.doc");
}
else
{
context.Response.Write("<b>DENIED</b>");
}

مراحل کد ارائه شده به صورت زیر است:
1. HttpHandler درخواست مربوط به یک فایل doc را دریافت میکند.
2. سپس شما یکسری چک کردن با دیتابیس برای اینکه متوجه شوید کاربر مجاز به استفاده است انجام میدهید.
3. اگر درخواست مجاز بود یک Binary Stream فایل را برای کاربر ارسال میکند.
4. اگر درخواست غیر مجاز بود برروی صفحه نوشته میشود Denied

HttpHandler یک ابزار بسیار قوی جهت کنترل دسترسی به محتویات موجود برروی وب سایت شما است.

از این روش میتوان در سایتهای E-Commerce و در جاهایی که لازم دسترسی به یک یا چند فایل محدود شود استفاده نمود. با این روش دیگر هیچ URL در کار نخواهد بود که کسی بتواند با منتشر کردن آن اطلاعات شما را بردارد.

همه مقالات کليات ASP.NET را ببينيد.
جستجو: بگرد!
جستجوی پيشرفته
نام کاربری |
کلمه عبور |


IranASP.NET - دستکاری تصاویر در ASP.NET

دستکاری تصاویر در ASP.NET

حسین روزنامه چی | اين مقاله ۴۱۰۵ بار تاکنون ديده شده است.
۱۳۸۴/۱/۲۴ | برای وبلاگ برای وبلاگ دريافت کد
در دات نت همیشه کارهای بزرگ را می توان با چند خط کوتاه، برنامه‌ی ساده انجام داد. یکی از این کارها ترسیم و دستکاری تصاویر است.

در دات نت همیشه کارهای بزرگ را می‌توان با چند خط کوتاه، برنامه‌ی ساده انجام داد. یکی از این کارها ترسیم و دستکاری تصاویر است. در این مقاله سعی می‌کنیم دستکاری تصاویر با دات نت را با هم مرور کنیم. یاد آور می‌شوم که مقاله‌ای در باب ترسیم، با نام گرافيک در ASP.NET توسط دوست خوبمان آقای مجتبی کيانی قبلا در سایت منتشر شده است که مطالعه آن به شما پيشنهاد می‌کنم.

در دات نت ترسیم یک تصویر همیشه با استفاده از شیئی از کلاس Graphics روی می‌دهد. و می‌دانیم متد DrawImage از این کلاس، متدی غنی برای اجرای کارهای گیج کننده گرافیکی به صورت خیلی ساده است. متد دیگری نیز با نام DrawImageUnscaled وجود دارد که این متد فقط وقتی مورد استفاده قرار می‌گیرد که مستطیل‌های منبع و مقصد همسان باشند.

قبل از هرچیز برای ترسیم باید بدانیم:

۱- همیشه یک مستطیل مقصد وجود دارد (در حقیقت مساحتی که تصویر داخل آن کپی میشود).
۲- همیشه یک مستطیل منبع وجود دارد که ممکن است تمام یا بخشی از تصویر اولیه را در بر بگیرد (در حقیقت مساحتی از تصویر اولیه که می‌خواهیم کپی شود).
۳- مستطیل مقصد ممکن است کوچکتر یا بزرگتر مستطیل منبع باشد (در این صورت اندازه تصویر ایحاد شده با اندازه تصویر اولیه فرق خواهد کرد).

همینطور دانستن نکات زیر برای ترسیم به ما کمک میکند:
۱- به هنگام ترسیم تصویر می‌توان با استفاده از ImageAttributes در تصویر تغییراتی داد، در این صورت بسیاری از عملیات پیچیده ترسیم به راحتی ممکن می‌گردد.
۲- شیئی از کلاسGraphics می‌تواند برای تغییر اندازه نیز استفاده شود، همینطور این شیئ دارای فیلترهای الحاقی میباشد که بر کیفیت و سیمای تصویر اثر میگذارند.

در مثال‌های زیر می‌بینیم که چطور متد DrawImage مورد استفاده قرار میگیرد. "myGraphics" شئی از کلاس graphics و "img" تصویری که در حافظه ذخیره شده است فرض شود. شما می‌توانید عملکرد هرقسمت را به ترتیب در مثال نمونه همراه این مقاله مشاهده کنید (توجه داشته باشید که چون این نمونه مثال روی دستگاه شما فایل result.jpg را می‌نویسد، ممکن است هنگام اجرا با ایراد امنیتی روبرو شوید، در این صورت به سند readme.doc در بین فایل‌های مثال رجوع کنید).

۱- یک کپی مستقیم از تصویر:

myGraphics.DrawImage(img,<point>)

نقاط X و Y مختصات گوشه بالا سمت چپ مستطیل منبع را بیان می‌کند. در این مثال مستطیل مقصد ما هم اندازه مستطیل منبع ما بود. اما اگر بخواهیم مستطیل مقصد بزرگ تر باشد (و در نتیجه تصویر بزرگ تر از حالت اولیه خود باشد) می‌توانید به صورت زیر عمل کنید توجه داشته باشد که در این حالت ممکن است تصویر کیفیت مطلوب خود را از دست بدهد (همینطور می‌توان مستطیل مقصد را کوچکتر از مستطیل منبع تعریف کرد که واضح است تصویر کوچکتر از تصویر اولیه خواهد بود).

۲- کپی با اندازه های متفاوت:

myGraphics.DrawImage(img,BiggerRectangle)

در این حالت مستطیل منبع کل تصویر اولیه خواهد بود (واضح است که BiggerRectangle مستطیل مقصد می‌باشد) اما اگر بخواهیم فقط قسمتی از تصویر اولیه را استفاده کنیم. مستطیل منبع باید قسمتی از تصویر اولیه باشد.

۳- انتخاب قسمتی از عکس اولیه:

DistRectangle=new Rectangle(100,100,10,10)// مستطیل مقصد
myGraphics.DrawImage(img, DistRectangle,75,40,10,10,GraphicsUnit.Pixel)

این مثال نشان می‌دهد که میتوان مستطیل منبع (یا مقصد) را مستقیما در پارامترهای DrawImage تعریف کرد. در ضمن در مورد GraphicsUnit، به یاد داشته باشیم که همیشه واحد گرافیک Pixel است. در مثال بالا مستطیل مقصد نیز به اندازه مستطیل منبع است. اما اگر بخواهیم اندازه قسمت کپی شده را تغییر دهیم باید مستطیل مقصد را با اندازه‌ای متفاوت از مستطیل منبع تعریف کنیم.

۴- انتخاب قسمتی از عکس اولیه و اعمال تغییر اندازه:

DistRectangle =new Rectangle(10,20,120,40) )// مستطیل مقصد
SourRectangle =new Rectangle(75,40,10,10) )// مستطیل منبع
myGraphics.DrawImage(img, DistRectangle, SourRectangle,GraphicsUnit.Pixel)

چرخاندن (Rotating) و تغییر صورت (transformation) یک تصویر نیز توسط شیئی از Graphics کلاس مقدور است. برای transformation باید یک ماتریس تعریف کنید. در این مثال، ما تصویر را به اندازه 30 درجه در جهت خلاف عقربه های ساعت می‌چرخانیم.

۵- چرخاندن با مقیاس درجه:

Matrix mx = new Matrix();
mx.Rotate(-30);
myGraphics.Transform = mx;
myGraphics.DrawImage(img,new Point(100,50));

یا می‌توانید به شکل زیر تغییر اندازه و چرخاندن را انجام دهید.

۶- چرخاندن با مقیاس طول و عرض:

Matrix mx = new Matrix();
mx.Translate(20.0F, 10.0F);
myGraphics.MultiplyTransform(mx);
myGraphics.RotateTransform(20.0F);

در این مثال 20.2F و 10.0F به ترتیب X و Yای هستند که به صورت ماترس ترجمه می‌شوند.

روش دیگری برای ایجاد تغییر زاویه وجود دارد و آن استفاده از مختصات نقاط به هنگام تعریف مستطیل‌ها است (تصویر حاصل از این روش حالتی آیینه‌ای نسبت به تصویر اولیه دارد). برای انجام این عمل مستطیل مقصد به صورت معمولی تعریف میشود اما به هنگام تعریف مستطیل منبع به شکل زیر عمل میکنیم.

۷- ایجاد حالت آینه‌ای:

Rectangle DistRectangle = new Rectangle(50,50,320,240);
Rectangle SourRectangle= new Rectangle(0, img.Height, img.Width,- img.Height);
myGraphics.DrawImage(img,DistRectangle,SourRectangle,GraphicsUnit.Pixel);

ترسیم تصویرهای شفاف توسط کلاس ImageAttributes انجام می‌شود. چنین شیئی میتواند یک ColorMatrix در خود ذخیره کند که توسط آن میتوان alphaی یک تصویر را هنگام ترسیم تغییر داد. از میان تمام propertyها میتوان به ColorMatrix.Matrix33 اشاره کرد که شما را قادر میکند کاملا شفافیت یک تصویر را تنظیم کنید.

۸- ترسیم های شفاف:

myGraphics.DrawImage(img1,new Point(0,0));
ImageAttributes ia = new ImageAttributes();
ColorMatrix cm = new ColorMatrix();
cm.Matrix33=0.5f;
ia.SetColorMatrix(cm);
myGraphics.DrawImage(img2,new Rectangle(0, 0, img2.Width, img2.Height ), 0, 0, img2.Width, img2.Height, GraphicsUnit.Pixel, ia);

۹- ایجاد Thumbnail از یک تصویر:
مطلب دیگری که خوب است در باره آن مختصری بحث شود ایجاد Thumbnail از یک تصویر است. اگرچه در این روش از شئی از Graphics استفاده نمی‌شود اما بجاست که استفاده از این روش برای کوچک کردن عکس ها با روش (شماره ۱۰) مورد مقایسه قرار گیرد. Thumbnailها تصویرهای کوچکی هستند که معمولا در گالری‌های تصویر برای پیش نمایش با اندازه کوچک و به تعداد زیاد در یک صفحه نمایش داده می‌شوند. برای تولید آن از روش زیر استفاده می‌کنیم:

System.Drawing.Image.GetThumbnailImageAbort myCallBack = new System.Drawing.Image.GetThumbnailImageAbort(ThumbnailCallback);
System.Drawing.Image imgResizedImage = MainPic.GetThumbnailImage(360,270,myCallBack,IntPtr.Zero);

پارامترها:
به ترتیب از چپ به راست: (عرض، طول، callback و callbackData) هستند که callback یک نماینده برای Image.GetThumbnailImageAbort است. در نگارش 1.0 +GDI، نماینده عملا مورد استفاده قرار نمی‌گیرد. اما شما حتماً باید یک نماینده بسازید و آن را به یک مرجع منتصب کنید (برنامه نمونه را نگاه کنید). callbackData نیز همیشه IntPtr.Zero است.

اگر تصویر اولیه، در خود Thumbnail به صورت ذخیره شده داشته باشد این متد آن را به اندازه خواسته شده تغییر اندازه می‌دهد و در غیر این صورت این متد با کوچک کردن سایز تصویر اصلی Thumbnail می‌سازد. برای ایجاد تصویرهایی با اندازه کوچک (برای مثال 120 در 120) این متد بسیار کار آمد است اما در صورتی که بخواهیم تصویر را در اندازه های بزرگ تری کوچک کنیم، احتمال افت کیفیت برای تصویرها وجود خواهد داشت. در این حالت توصیه می‌شود که تصویر اصلی را با استفاده ازDrawImage کوچک کنید. روش زیر برای تغییر اندازه تصویرها در اندازه‌های بزرگتر روشی کارآمدتر است.

۱۰- تغییر اندازه:

System.Drawing.Image NewImage = new System.Drawing.Bitmap(300,300);
System.Drawing.Graphics NewImageGraphics = System.Drawing.Graphics.FromImage(NewImage);
Rectangle DistRectangle = new Rectangle(0,0,NewImage.Width,NewImage.Height);
Rectangle SourRectangle = new Rectangle(0,0,my1stImage.Width,my1stImage.Height);
NewImageGraphics.DrawImage(my1stImage,DistRectangle,SourRectangle,GraphicsUnit.Pixel);

در این روش یک Image جدید با نام NewImage را از نوع Bitmap و با اندازه های دلخواه تعریف کردیم و در حقیقت یک کپی از تصویر اولیه را با مستطیل منبع هم اندازه تصویر اولیه روی تصویر جدید با اندازه مستطیل مقصد هم اندازه تصویر جدید ترسیم کردیم.

تمام مباحث به ترتیب در برنامه‌ای گرد آورده شده است. این برنامه دو تصویر را از روی دستگاه شما (سرور) می‌خواند و حاصل هر مرحله را در تصویری با نام result.jpg ذخیره میکند و آن را نمایش می‌دهد. برای اجرای این برنامه کافی است IIS و NET Framework. روی دستگاه شما نصب شده باشد.

همه مقالات کليات ASP.NET را ببينيد.
جستجو: بگرد!
جستجوی پيشرفته
نام کاربری |
کلمه عبور |


IranASP.NET - جستجو با استفاده از وب سرویس گوگل - قسمت اول

جستجو با استفاده از وب سرویس گوگل - قسمت اول

حامد سعیدی فرد | اين مقاله ۳۷۱۶ بار تاکنون ديده شده است.
۱۳۸۴/۲/۷ | برای وبلاگ برای وبلاگ
گوگل به برنامه نویسان یک وب سرویس برای جستجو در دیتابیس خود پیشنهاد می کند. به کمک این وب سرویس شما قادر خواهید بود تا یک وب سایت مشخص یا کل وب را به کمک شاخص های گوگل جستجو کنید و نتایج را به صورت سفارشی شده در وب سایت خود نمایش دهید. در این مقاله به چگونگی استفاده از این وب سرویس در صفحات ASP.NET خواهیم پرداخت.

معرفی

آیا می دانید گوگل برای جستجو در دیتابیس خود، دریافت نسخه cache شده یک وب سایت و همچنین استفاده از سرویس spelling check یک وب سرویس فراهم کرده است؟ استفاده از وب سرویس گوگل می تواند جستجوی گوگل را برای سایت شما فراهم کند. در اولین بخش این مقاله، ما به چگونگی استفاده از این وب سرویس برای جستجو در دیتابیس گوگل خواهیم پرداخت.

API وب سرویس گوگل

اطلاعات وب سرویس گوگل را می توانید در آدرس http://www.google.com/apis پیدا کنید. برای شروع استفاده از وب سرویس گوگل شما باید Google Web API Developer's Kit را دانلود کنید. این فایل 666 کیلو بایتی شامل فایل WSDL ( زبان توصیف وب سرویس) است که کاملا وب سرویس را توصیف می کند و نیز مثال هایی جهت دسترسی به این وب سرویس با زبان های جاوا، ویژوال بیسیک و سی شارپ دات نت دارد.

بعد از دانلود API Developer's Kit، شما باید یک اکانت در گوگل بسازید، این کار را می توانید از طریق آدرس زیر انجام دهید.https://www.google.com/accounts/NewAccount?continue=http://api.google.com/createkey .
بعد از اینکه یکی از این اکانت های مجانی را ساختید. شما باید یک کلید لایسنس یکتا تعیین کنید. این کلید لایسنس باید هر دفعه که شما وب سرویس گوگل را فرامی خوانید استفاده شود. هدف این مجوز، محدود کردن درخواست وب سرویس ها به 1000 عدد در روز به ازای هر کلید لایسنس است.

ساختن کلاس پراکسی

بعد از اینکه کلید مجوز و کیت توسعه دهندگان را دریافت کردید، قدم بعدی ساخت یک کلاس پراکسی برای فراخوانی وب سرویس است. برای انجام این کار ما ابتدا به دستکاری در فایل WSDL نیاز داریم، این یک فایل به فرمت XML است که سرویس ارائه شده توسط وب سرویس گوگل را توصیف می کند. این فایل WSDL ، GoogleSearch.wsdl در کیت توسعه دهندگان مشخص شده است.

اگر از ویژوال استودیو دات نت استفاده می کنید، این فایل را در یک دایرکتوری ASP.NET ( مثلا C:\Inetpub\wwwroot\WebApplication1 ) کپی کنید. سپس در ویژوال استودیو به منوی Project بروید و گزینه Add Web Reference را انتخاب کنید. سپس در جعبه محاوره، آدرس فایل WSDL را وارد کنید، که چیزی شبیه به http://localhost/WebApplication1/GoogleSearch.wsdl خواهد بود . برای تکمیل عملیات روی دکمه Add Reference کلیک کنید. این کار یک کلاس پراکسی با استفاده از فضا نام localhost می سازد ( که در صورت تمایل می توانید آن را تغییر دهید).

اگر ویژوال استودیو دات نت ندارید، می توانید از طریق برنامه خط فرمان به نام wsdl.exe یک کلاس پراکسی بسازید. wsdl.exe یک فایل سی شارپ یا VB.NET می سازد که شما پس از آن احتیاج به کامپایل خواهید داشت. برای اجرای wsdl.exe در خط فرمان دستور زیر را وارد کنید:

wsdl /protocol:SOAP /namespace:google /out:GoogleProxy.cs C:\google\GoogleSearch.wsdl

این کار یک فایل سی شارپ به نام GoogleProxy.cs با فضا نام google می سازد. برای کامپایل این کلاس از کامپایلر خط فرمانی سی شارپ یعنی csc به صورت زیر استفاده کنید:

csc /t:library /out:GoogleProxy.dll GoogleProxy.cs

این کار برای شما یک فایل به نام GoogleProxy.dll می سازد . مطمئن شوید که یک کپی از این فایل در دایرکتوری bin برنامه وبی شما باشد!

ساخت یک صفحه وبی ASP.NET برای فراخوانی وب سرویس گوگل

حالا که کلاس پراکسی را ساخته ایم، فراخوانی وب سرویس گوگل از طریق یک صفحه وب کار آسانی است. قبل از امتحان کردن این کار باید پارامترهایی که متدهای وب سرویس انتظارشان را دارند بشناسیم. خوشبختانه این متدها و پارامترهای ورودی شان در بخش مرجع در وب سایت گوگل کاملا معرفی شده اند. چون در این مقاله ما روی استفاده از متدهای جستجو تمرکز کرده ایم اجازه بدهید تا پارامتر های متد doGoogleSearch را با هم بررسی کنیم. این متد 10 پارامتر ورودی دارد:

نام | توضیح
key | بوسیله گوگل فراهم شده است، این کلید برای شما لازم است تا به سرویس وب گوگل دسترسی داشته باشید، گوگل این کلید را برای احراز هویت و ثبت استفاده می کند.
q | بخش اصطلاحات پرس و جو را برای اطلاعات بیشتر در مورد گرامر کوئری ببینید
start | یک شاخص Zero-based از اولین نتیاج دلخواه
maxResults | تعداد نتایج دلخواه برای هر پرس وجو، بیشترین مقدار برای هر پرس و جو 10 تاست. توجه : اگر شما پرس و جویی را انجام دهید که نتایج زیادی ندارد، مقدار واقعی نتایجی که دریافت می کنید ممکن است کمتر از آن چیزی باشد که درخواست کرده اید.
filter | فعال یا غیرفعال کردن فیلتراتوماتیک نتایج، که نتایج بسیار شبیه به هم یا نتایجی که همگی از یک وب هوست آمده اند را مخفی می کند. برای اطلاعات بیشتر بخش فیلترینگ اتوماتیک را ببینید.
restricts | محدود کردن جستجو به یک زیر مجموعه شاخص های وب گوگل، به عنوان مثال محدود کردن به کشوری مثل اوکراین یا موضوعی مثل لینوکس . برای اطلاعات بیشتر بخش محدود کردن را ببینید.
safeSearch | یک مقدار بول که مشخص که فیلتر محتوای بالای 18 سال را در نتایج جستجو فعال می کند. بخش جستجوی امن را برای کسب اطلاعات بیشتر ببینید.
lr | محدود کردن زبان - محدود کردن جستجو در میان اسناد یک یا چند زبان خاص
ie | Input Encoding - تمام درخواست ها به API باید بوسیله UTF-8 باشد. برای اطلاعات بیشتر بخش انکودینگ ورودی و خروجی را ببینید.
oe | Output Encoding - تمام درخواست ها به API باید بوسیله UTF-8 باشد. برای اطلاعات بیشتر بخش انکودینگ ورودی و خروجی را ببینید.

متد doGoogleSearch نمونه ای از شی GoogleSearchResult را برمی گرداند. این شی یک مشخصه به نام resultElements دارد که آرایه ای از اشیا موسوم به ResultElement می باشد. شی ResultElement تعدادی مشخصه دارد، مثل عنوان، آدرس، خلاصه و چیزهایی از این دست.

حالا اجازه بدهید که یک صفحه ASP.NET ساده بسازیم تا 10 نتیجه اول را برای پرس و جوی عبارت "ASP" برگرداند. این کار را به کمک کد زیر می توان انجام داد:

<script language="VB" runat="server">
  Sub Page_Load(sender as Object, e as EventArgs)
    Dim search As google.GoogleSearchService = New google.GoogleSearchService()
    Dim result as google.GoogleSearchResult

    result = search.doGoogleSearch("license key...", "ASP", _
                              0, 10, True, "", True, "", "", "")

    dlResults.DataSource = result.resultElements
    dlResults.DataBind()
  End Sub
</script>

<asp:DataList runat="server" id="dlResults"
      Font-Name="Verdana" Font-Size="10pt">
  <ItemTemplate>
    <span style="font-size:15pt;font-weight:bold;">
      <%# Container.DataItem.title %>
    </span><br />
    <%# Container.DataItem.summary %><br />
    [<a href="<%# Container.DataItem.URL %>">
        <%# Container.DataItem.URL %>
     </a>]
  </ItemTemplate>

  <SeparatorTemplate>
    <p>آ </p>
  </SeparatorTemplate>
</asp:DataList>

در متن ضخیم (Bold) کد لازم برای فراخوانی متد doGoogleSearch در وب سرویس گوگل نشان داده شده است. نتایج جستجو در یک دیتالیست به نمایش درخواهند آمد، به همراه هر نتیجه، عنوان، خلاصه و آدرس دسترسی به آن صفحه نمایش داده می شود.

در قسمت دوم این مقاله خواهیم دید که چگونه یک صفحه ASP.NET مفیدتر که از وب سرویس گوگل استفاده می کند بنویسیم.

همه مقالات سرويس های XML وب را ببينيد.
جستجو: بگرد!
جستجوی پيشرفته
نام کاربری |
کلمه عبور |


IranASP.NET - جستجو با استفاده از وب سرویس گوگل - قسمت دوم

جستجو با استفاده از وب سرویس گوگل - قسمت دوم

حامد سعیدی فرد | اين مقاله ۲۵۸۴ بار تاکنون ديده شده است.
۱۳۸۴/۲/۲۶ | برای وبلاگ برای وبلاگ
گوگل به برنامه نویسان یک وب سرویس برای جستجو در دیتابیس خود پیشنهاد می کند. به کمک این وب سرویس شما قادر خواهید بود تا یک وب سایت مشخص یا کل وب را به کمک شاخص های گوگل جستجو کنید و نتایج را به صورت سفارشی شده در وب سایت خود نمایش دهید. در این مقاله به چگونگی استفاده از این وب سرویس در صفحات ASP.NET خواهیم پرداخت.

در قسمت قبل این مقاله دیدید که چگونه به کمک وب سرویس گوگل در وب جستجو می کنیم. در قسمت دوم خواهیم دید که چگونه می توان یک موتور جستجوی شبه گوگل ایجاد کرد.

ساختن یک موتور جستجوی کاربردی تر
برای ساختن یک موتور جستجوی کاربردی تر با وب سرویس گوگل، اجازه دهید تا یک صفحه وب ASP.NET بسازیم که به کاربر امکان وارد کردن عبارت مورد جستجو و همچنین صفحه بندی داده های بدست آمده از جستجو را بدهد. یک راه برای انجام این کار، تقلید از گوگل است به این معنی که کلمه مورد جستجو و شماره صفحات را در Query String قرار دهیم. به عنوان مثال اگر کاربر کلمه "ASP" را جستجو کند و 10 نتیجه از 20 نتیجه بدست آمده نمایش داده شود، آدرس درخواستی چیزی شبیه به این خواهد بود :
< BR>http://www.yourserver.com/Search.aspx?q=ASP&first=10&last=20

یک انتخاب دیگر استفاده از postback است. اما استفاده از Query String این حسن را دارد که کاربر می تواند نتایج یک جستجوی خاص را bookmark کند (توجه کنید که در روش postback به دلیل استفاده از هدرهای HTTP POST، آدرس و Query string موقع جستجو یا صفحه بندی نتایج تغییری نمی کنند).

با وجود مزیت bookmark شدن در روش Query String من تصمیم گرفتم تا کار را به کمک Postback در وب فرم ها انجام دهم، اما شما اگر بخواهید، می توانید روش Query String را تعریف و استفاده کنید. سورس کد روش Postback را در زیر مشاهده می کنید :

<script language="VB" runat="server">
Const PAGE_SIZE as Integer = 5

Sub execSearch(sender as Object, e as EventArgs)
ViewState("startIndex") = 0

DisplaySearchResults()
End Sub

Sub nextRecs(sender as Object, e as EventArgs)
ViewState("startIndex") += PAGE_SIZE

DisplaySearchResults()
End Sub

Sub prevRecs(sender as Object, e as EventArgs)
ViewState("startIndex") -= PAGE_SIZE

DisplaySearchResults()
End Sub

Sub DisplaySearchResults()
searchResults.Visible = True

Dim search As google.GoogleSearchService = New google.GoogleSearchService()
Dim result as google.GoogleSearchResult

result = search.doGoogleSearch("license key...", searchTerms.Text, _
ViewState("startIndex"), PAGE_SIZE, True, "", True, "", "", "")

dlResults.DataSource = result.resultElements
dlResults.DataBind()

lblSearchResults.Text = "Viewing records " & String.Format("{0:#,###}", _
ViewState("startIndex")+1) & " - " & _
String.Format("{0:#,###}", ViewState("startIndex") + _
PAGE_SIZE) & " of about " & _
String.Format("{0:#,###}", result.estimatedTotalResultsCount) & _
". Search took " & _
String.Format("{0:0.000}", result.searchTime) & " sec."

btnPrev.Enabled = (ViewState("startIndex") > 0)
End Sub
</script>

<form runat="server">
Enter your search term: <asp:TextBox runat="server" id="searchTerms" />
<asp:Button runat="server" Text="Search" OnClick="execSearch" />
<p>
<asp:panel id="searchResults" runat="server" Visible="False">
<table width="100%" bgcolor="#eeeeee">
<tr><td align="right">
<asp:Label id="lblSearchResults" runat="server" />
</td></tr>
</table>

<asp:DataList runat="server" id="dlResults"
Font-Name="Verdana" Font-Size="10pt">

<ItemTemplate>
<span style="font-size:15pt;font-weight:bold;">
<%# Container.DataItem.title %>
</span><br />
<%# Container.DataItem.snippet %><br />
[<a href="<%# Container.DataItem.URL %>"><%# Container.DataItem.URL %></a>]
</ItemTemplate>

<SeparatorTemplate>
<p> </p>
</SeparatorTemplate>

</asp:DataList>

<table width="100%" bgcolor="#eeeeee">
<tr><td align="right">
<asp:LinkButton id="btnPrev" runat="server" Text="< Prev." OnClick="prevRecs" /> |
<asp:LinkButton id="btnNext" runat="server" Text="Next. >" OnClick="nextRecs" />
</td></tr>
</table>
</asp:Panel>
</form>

[مشاهده نمونه کامل شده]

مهمترین و اصلی ترین و پر کارترین تابع در کد بالا DisplaySearchResults است که وب سرویس را فراخوانی می کند، داده ها را به دیتالیست مقید ( bind ) می کند و اطلاعات متفرقه در مورد نتیجه پیدا شده مثل عدد تخمینی تعداد نتایج، زمان اجرای کوئری و... را نمایش می دهد. این تابع همچنین فعال یا غیر فعال بودن دکمه لینکی مربوط به صفحه بندی نتایج را مشخص می کند.

هنگامی که وب سرویس را فراخوانی می کنیم، باید شاخص شروع نتایج و نیز تعداد نتایجی که می خواهیم در یک صفحه ببینیم را مشخص کنیم. برای اینکه 10 رکورد اول نتایج جستجو را ببینیم، عدد صفر را به عنوان شاخص شروع و عدد 10 را به عنوان تعداد رکوردهای بازگشتی پاس می کنیم. برای دیدن 10 نتیجه بعدی، فقط کافی است که عدد 10 را به عنوان شاخص شروع پاس کنیم (تعداد رکوردهای بازگشتی در این حالت هم همان 10 تاست). توجه کنید که ViewState برای مدیریت عدد شاخص شروع به کار رفته است. تعداد رکوردهایی که در هر صفحه نمایش داده می شوند توسط ثابت PAGE_SIZE مشخص می شود.

برای امکان صفحه بندی نتایج از دو دکمه لینکی استفاده شده است که وقتی روی آن ها کلیک می شود هندلرهای nextRecs و prevRecs شروع به کار می کنند. این هندلرها تنها عدد شروع رکوردها را به روز رسانی کرده و سپس DisplaySearchResults() را فراخوانی می کنند.

یک نکته مهم در رابطه با وب سرویس گوگل :
API وب سرویس گوگل در حال حاضر در مرحله تست بتا قرار دارد و تنها برای مصارف شخصی آماده شده است، برای محدود کردن استفاده افراطی، گوگل از استفاده کنندگان این سرویس می خواهد تا یک license key منحصر به فرد داشته باشند (که به صورت مجانی قابل دریافت است)، توضیح روش دریافت license key در قسمت اول این مقاله آمده است . این license key برای محدود کردن فراخوانی وب سرویس به کمتر از 1000 بار در روز استفاده می شود. لطفا api license terms را برای استفاده از وب سرویس گوگل مطالعه کنید.

منبع: Searching Google Using the Google Web Service

همه مقالات سرويس های XML وب را ببينيد.
جستجو: بگرد!
جستجوی پيشرفته
نام کاربری |
کلمه عبور |


IranASP.NET - کنترل‌های پویا

کنترل‌های پویا

سعد شمسایی | اين مقاله ۲۱۳۰ بار تاکنون ديده شده است.
۱۳۸۴/۳/۲ | برای وبلاگ برای وبلاگ
چگونگی اضافه کردن یک کنترل کاربری (User Control) در مواقع لازم با استفاده از متد LoadControl

شما با استفاده از کنترل های ASP.net اجزاء مورد نظر برنامه وب خود را در یک صفحه وارد می کنید. این صفحات خود ممکن است تنها HTML و یا در برگیرنده کدهای net. باشند. کنترل ها بصورت ascx. ذخیره می شوند و برای استفاده از آنها بصورت زیر با صفحه aspx شما پیوند می خورند و بصورت یک tag ساده می توان آنها را به هر قسمت از صفحه اضافه کرد.

<%@ Register TagPrefix="uc1" TagName="HeaderUserControl" Src="HeaderUserControl.ascx" %>
...

<uc1:HeaderUserControl id="Header1" runat="server"></uc1:HeaderUserControl>

و اما شاید شما بخواهید فقط در مواقعی خاص این کنترل ها load شوند. مثلا هنگام اجرای متد Page_Load و یا Button_Click ، در صورت درست بودن نام کاربری و یا به هر شکل دیگری. چاره چیست؟! خوشبختانه کتابخانه net. با متد LoadControl خود میتواند پاسخ گوی شما باشد (در ضمن این را هم فراموش نکنید که هر tag ساده html و یا کنترل سمت سرور ASP. net را با زبان برنامه نویسی net. هم می توان ایجاد کرد). فرض کنید ما کنترلی به اسم FeaturedProduct.ascx داریم. بدین صورت ابتدا بارگذاری و سپس اضافه خواهد شد:

Control FeaturedProductUserControl = LoadControl("FeaturedProduct.ascx");

Controls.Add(FeaturedProductUserControl);
البته اشکال این تکنیک این است کنترل دقیقا محلی که شما می خواهید اضافه شود نمایش داده نمی‌شود که خب، این هم با استفاده از place holder's controls collection قابل حل هست. بدین شکل:

PlaceHolderLeftMenu.Controls.Add(FeaturedProductUserControl);

مطمئناً این تکنیک برای کسانی که برنامه های کاربردی تحت وب را پیاده می کنند جهت مدیریت بهتر، استفاده از صفحات کمتر، حالت های مختلف درخواست‌ها و کلاً قالب بندی CMS‌ها بسیار مفید خواهد بود، چنانچه که پروژه ای مثل IBuySpy نیز از این تکنیک بهره می‌برد.

منبع: ASPAlliance

همه مقالات فرم های وب را ببينيد.
جستجو: بگرد!
جستجوی پيشرفته
نام کاربری |
کلمه عبور |


IranASP.NET - کوکی ها در ASP.NET

کوکی ها در ASP.NET

محمد علويان | اين مقاله ۲۰۸۵ بار تاکنون ديده شده است.
۱۳۸۴/۴/۷ | برای وبلاگ برای وبلاگ
اين مقاله توضيح می دهد که چگونه می توان کوکی‌ها را با استفاده از ASP.NET ساخت، خواند و يا حذف کرد.

کوکی ها برای ذخيره مقدار کمی اطلاعات بر روی دستگاه مشتری (CLIENT) استفاده می شوند. يك کوکی می تواند حداکثر تا 4 کيلو بايت را ذخيره کند. بطور کلّی کوکی ها برای ذخيره داده هايی که اغلب کاربر تايپ می کند استفاده می شوند، از قبيل اسم کاربری و پسورد برای لاگين در سايت.

دو نوع کوکی وجود دارد: زمانی (session) و دائمی (persistent ). کوکی های زمانی کوکی های موقتی نيز خوانده می شوند که در حافظه مرورگر ذخيره می شوند و زمان حیات آنها به مرورگر بستگی دارد. هنگامی که شما مرورگر را می بنديد اين کوکی ها هم می ميرند. از طرف ديگر کوکی های پايدار بر روی هارد ديسک با اطلاعات تاریخ ذخيره می شوند و برای زمان درازی می توانند زنده بمانند. هنگامی که شما کوکی های پايدار را ايجاد می کنيد شما می توانيد زمان زندگی کوکی را نيز تعیین کنيد. اگر چه مدتی که شما تعیین می کنيد تا کوکی زنده بماند قطعی نيست. همچنين اگر چه کوکی ها شئ‌های مفيدی در دنيای وب هستند امّا آنها برخی محدودیت هایی هم دارند. مثلاً کوکی ها نمی توانند اطلاعات زيادی را در خود ذخيره کنند.

همچنين کوکی ها وابسته به مرورگرها هستند به اين معنی که کوکی کاربردی در برخی مرورگرها نمی تواند کار کند. شما می توانيد زمان زندگی يک کوکی را تعیین کنيد اما نمی توان تضمين کرد که کوکی در آنجا برای مدت طولانی در دسترس باشد. بنابراين ذخيره اطلاعات مهم در کوکی ها ايده خوبی نيست.

ساختن و خواندن کوکی‌ها
كلاس HttpCookie در فضانام System.Web تعريف شده است که کوکی ها را نمايش می دهد. خواص کوکی‌ها مثل Response و Request می تواند در خواندن تمام کوکی ها به کار رود بطوريکه شئ HttpCookieCollection می تواند همه کوکی ها را نمايش می دهد.

همانند دیگر کلاس ها کلاس HttpCookieCollection اضافه کردن حذف کردن و خواندن کوکی ها را از مجموعه برای اعضا فراهم می کند. شما می توانيد يک کوکی توسط کلاس HttpCookie با مشخص کردن نام و مقدار کوکی به صورت رشته ای ايجاد کنيد. يا شما می توانيد از خواص Name و Value برای نام و مقدار کوکی استفاده کنيد. خاصيت Expires کلاس HttpCookie يک کوکی پايدار می سازد و زمانی را که کوکی از بين خواهد رفت مشخص می کند. در قطعه کد زير دوتا کوکی می سازد به نام UID وPASS. شما در اين کد می توانيد ببينيد که ما کوکی ها را به مجموعه توسط تابع Response.Cookies.Add اضافه می کنيم:

Listing 1. Creating cookies

' ساختن اسم کاربری و پسورد کوکی ها
' دادن مقدار به آنها و اضافه کردن به مجموعه
Dim cookie As HttpCookie = New HttpCookie("UID")
cookie.Value = "myid"
cookie.Expires = #9/28/2002#
Response.Cookies.Add(cookie)
cookie = New HttpCookie("PASS")
cookie.Value = "mypass"
cookie.Expires = #9/28/2002#
Response.Cookies.Add(cookie)

شما می توانيد کوکی ها را با استفاده از صفت Request.Cookies بخوانيد. قطعه کد زير کوکی را از مرورگر می خواند و آنها را به کنترل ListBox اضافه می‌کند:

Listing2 . Read cookies

' خواندن کوکی ها
Dim cookieCols As New HttpCookieCollection()
cookieCols = Request.Cookies
Dim str As String
' خواندن و اضافه کردن تمام کوکی ها به لیست باکس
For Each str In cookieCols
ListBox1.Items.Add("Cookie: " + str)
ListBox1.Items.Add("Value:" & _
Request.Cookies(str).Value)
Next

شما می توانيد از توابع Clear و Remove در HttpCookieCollection برای حذف کوکی خاص يا همه کوکی ها استفاده کنيد. قطعه کد زير با استفاده از تابع Remove کوکی‌ها را حذف می کند:

Listing3 . Deleting cookies

Dim cookieCols As New HttpCookieCollection()
cookieCols = Request.Cookies
Dim str As String
' خواندن و حذف تمام کوکی ها از لیست باکس
Request.Cookies.Remove("PASS")
Request.Cookies.Remove("UID")

يک کوکی همچنين می تواند چندين مقدار را ذخيره کند. اين نوع کوکی، کوکی ديکشنری ناميده می شود. شما می توانيد از صفت Values برای ايجاد و خواندن اين نوع کوکی ها استفاده کنيد. کد زير يک کوکی ديکشنری می سازد.

Listing4 . Creating a dictionary cookie

Dim cookDict As HttpCookie = New HttpCookie("dict")
cookDict.Values("fname") = "first name"
cookDict.Values("lname") = "last name"
cookDict.Values("Address") = "address"
Response.Cookies.Add(cookDict)

منبع: Asp.Heaven

همه مقالات کليات ASP.NET را ببينيد.
جستجو: بگرد!
جستجوی پيشرفته
نام کاربری |
کلمه عبور |


IranASP.NET - برنامه نویسی شئ گرا در VB.NET (قسمت اول)

برنامه نویسی شئ گرا در VB.NET (قسمت اول)

کامیار راستا | اين مقاله ۲۰۲۸ بار تاکنون ديده شده است.
۱۳۸۴/۴/۲۳ | برای وبلاگ برای وبلاگ
امروزه برنامه‌های کاربردی بر پایه شئ‌گرایی استوارند. تکنولوژی NET. امکانات بسیار جالب و کاملی در این زمینه دارد این مقاله که از کتاب ارزشمند Developing windows-based applications with microsoft VB.net & C#.net برگرفته شده است به شما کمک می‌کند با مفاهیم و چگونگی استفاده از این امکانات آشنا شوید. مطالبی مانند کلاسها، اشیا، اینترفیس ها، چند ریختی و وراثت. همچنین می تواند به عنوان مرجعی برای استفاده از امکانات برنامه نویسی شئ گرا در VB.net قرار گیرد.

مقدمه ای بر برنامه نویسی شئ گرا
برنامه نویسی در محیط دات نت فریم ورک بر پایه اشیا انجام می گیرد. اشیا طرحهای برنامه پذیرند که می توانند نمونهایی از بسته های از دادهای مرتبط و دستورات باشند. اشیا طرحهای کامل و خاصی برای دیگر اعضای محیط برنامه هستند، بدون این که جزییات کارهای درونی خود شی مطرح شود. اشیا از یک قالب به نام کلاس ساخته می شود. کلاسهای کتابخانه ای پایه NET. یک سری کلاسهایی برای درست کردن اشیا در برنامهایتان آماده کرده اند. همچنین شما می توانید از محیط برنامه نویسی Microsoft Visual Studio برای درست کردن کلاسهای اختصاصی خودتان استفاده کنید. در این مقاله شما با مقدمات برنامه نویسی شئ گرا آشنا می شوید.

اشیا، اعضا و تجرد (Abstraction)
یک شئ (object) یک طرح برنامه پذیر است که چیزهایی ر ا نشان می دهد. در دنیای واقعی، ماشین، دوچرخه، کامپیوتر و... شئ هستند. هر کدام از این اشیا یک سری اعمال و خصوصیات دارند. در برنامه شما، یک شئ شاید یک فرم یا یک کنترل مانند یک دکمه(button) یا یک database connection یا هر طرح دیگری باشد. هر شئ یک واحد عملیاتی کامل است، و شامل همه دادهای مورد نیازش و دارای همه ی اعمالی که برای آن ساخته شده است می باشد.

کلاس ها (Classes)
کلاسها قالب هایی برای اشیا هستند. کلاسها را می توان، "طرحهای اولیه" برای اشیا فرض کرد. آنها تمام عضوهای یک شئ را تعیین می کنند، و رفتارهای یک شئ را تعریف می کنند. وقتی که یک کلاس مقدار دهی شد، یک نمونه درون حافظه ای از آن کلاس ساخته می شود. این نمونه شئ نامیده می شود. برای نمونه سازی از کلاس از کلمه کلیدی New استفاده می شود.

' Declares a variable of the Widget type

Dim myWidget As Widget

' Instantiates a new Widget object and assigns it to the myWidget

' variable

myWidget = New Widget()

وقتی یک نمونه از کلاس ساخته می شود، یک کپی از نمونه ی داده بوسیله آن کلاسی که در حافظه ساخته شده تعریف می شود و به مرجع متغییر داده می شود. هر نمونه از کلاس مستقل از دیگر نمونه هاست و می تواند یک طرح جداگانه‌ی برنامه پذیر باشد. درهر لحظه، محدودیتی برای تعداد کپی های یک کلاس (که قبلا تعریف شده) وجود ندارد. برای مقایسه، در جهان واقعی، اگر ماشین یک شئ باشد، کلاس یک طرح برای ماشین است. یک طرح می تواند برای هر تعداد ماشین مورد استفاده قرار گیرد و تغییرات برروی یک ماشین، تغییری بر دیگر ماشین ها نمی گذارد.

اشیا و اعضا(Members)

اشیا ترکیبی از عضوها هستند. اعضا، تشکیل شده از خصوصیات(Properties)، فیلدها، متدها و رویدادها (events) و هر چیزی که اطلاعات و اعمالی داشته باشد. فیلدها و خصوصیات، اعضای داده هر شئ‌ای هستند. متدها اعمالی هستند که شئ می تواند انجام دهد و رویدادها اطلاعاتی هستند که یک شئ به اشیا دیگر می فرستد یا از آنها دریافت می کند در زمانیکه اتفاقی در برنامه می افتد. در مثال واقعی مان، شئ ماشین، فیلدها و خصوصیاتی مانند Color ،Make ،Model ،Age، GasLevel دارد. این اطلاعات وضعیت شئ ماشین را توصیف می کند. شئ ماشین شاید چندین متد مانند Accelerate, shiftgears, turn داشته باشد. متدها رفتاری که شئ می تواند اجرا کند را نشان می دهند. ماشین شاید رویداد EngineOverheating از طرف شئ "موتورش" داشته باشد، یا وقتی با شئ "درخت" تعامل می کند، شاید رویداد "تصادف" برای آن اتفاق بیفتد.

کپسوله سازی( Encapsulation)
کپسوله سازی روشی است که یک شئ را مستقل از اینترفیسش پیاده سازی کنیم. یک برنامه با یک شئ بواسطه اینترفیسش تعامل می کند، که شامل خصوصیات عمومی و متدهایش است. تا زمانی که این اینترفیس ثابت باقی می ماند، برنامه می تواند به تعامل با کامپوننت ادامه دهد. حتی اگر پیاده سازی اینترفیس کاملا بین دو نسخه کاملا بازنویسی شده باشد. اشیا فقط از طریق متدها و خصوصیات عمومیشان با دیگر شئ ها تعامل می کنند. داده های داخلی یک شئ، نباید در اینترفیس قرار بگیرد. بنابراین فیلدها به ندرت Public تعریف می شوند. به مثال ماشینمان برگردیم: اگر شئ ماشین با شئ راننده تعامل کند، اینترفیس ماشین شاید شامل متدهای GoForward، Backward و متد Stop باشد. این همه‌ی اطلاعاتی است که راننده برای تعامل با ماشین نیاز دارد. ماشین شاید شامل شئ "موتور" نیز باشد، اما راننده نیازی به شناخت شئ موتور ندارد. همه اطلاعتی که راننده درباره این متدها دارد این است که می توانند فراخوانی شوند و آنها مقادیر ویژهای را برمی گردانند. بنابراین اگر شئ موتور تغییری کند، تا زمانیکه اینترفیس به درستی به کار خود ادامه می دهد این امر تفاوتی برای راننده ایجاد نمی کند.

چند شکلی(Polymorphism)
چند شکلی توانایی کلاسهای متفاوت، در پیاده سازی های مختلف از اینترفیسهای عمومی مشابه است. به عبارت دیگر، چندشکلی به متدها و خصوصیات یک شئ اجازه می دهد، بدون توجه به چگونگی پیاده سازی اعضای آنها، فراخوانی شوند. برای مثال شئ Driver می تواند بوسیله اینترفیس عمومی Car با شئ Car تعامل کند.اگر شئ دیگری مانند شئ Truck یا شئ SportCar اینترفیس عمومی مشابهی را داشته باشند، شئ Driver می تواند با آنها بدون توجه به پیاده سازی خاص آن اینترفیس تعامل کند این جا دو راه اصلی برای تامین چندشکلی وجود دارد: چندشکلی اینترفیس(interface polymorphism) و چندشکلی وراثتی (inheritance polymorphism).

چندشکلی اینترفیس(interface polymorphism)
اینترفیس یک قرارداد برای رفتار است. در واقع اینترفیس اعضای یک کلاس را تعیین می کند، اما توضیحاتی درباره‌ی پیاده سازی همه جزییات آن نمی دهد. یک شئ می تواند اینترفیسهای زیاد و متفاوتی را پیاده سازی کند، و کلاسهای متفاوت زیادی می توانند یک اینترفیس مشابه را پیاده سازی کنند. همه اشیایی که اینترفیس مشابهی را پیاده سازی می کنند می توانند با دیگر اشیا درون اینترفیس تعامل کنند. به عنوان مثال شئ car مثال قبل شاید اینترفیس IDrivable را پیاده سازی کند(به عنوان قرار داد، اینترفیس ها معمولا با I شروع می شوند)، که متدهای GoForward, GoBackward,Halt را تعیین می کند. کلاس های دیگر مانند Truck، Forklift یا Boat شاید این انیترفیس را پیاده سازی کنند و بنابراین می توانند با شئ Driver تعامل داشته باشند. شئ Driver از پیاده سازی انیترفیس که با آن تعامل دارد بی اطلاع است.

چندشکلی وراثتی (inheritance polymorphism)
وراثت به شما امکان می دهد که اعمال یک کلاس از پیش تعریف شده را، در یک کلاس جدید با هم ترکیب کنید و اعضای متفاوت مورد نیاز را در آن پیاده سازی کنید. کلاسی که از کلاس دیگری ارث می برد "مشتق" آن کلاس، یا "وارث" آن کلاس نامیده می شود. یک کلاس می تواند مستقیما فقط از یک کلاس ارث ببرد، که آن کلاس که از آن ارث می برد را کلاس پایه (base class) می نامند. کلاس جدید اعضای مشابهی با کلاس پایه دارد، و اعضای اضافی که مورد نیاز باشند می توانند افزوده شوند. به علاوه، در کلاس جدید بوسیله overriding پیاده سازی کلاس پایه، اعضای پایه می توانند تغییر کنند. کلاسهای وارث، همه ویژگی های کلاس پایه را نگه می دارند و می توانند با دیگر اشیایی که نمونه هایی از کلاس پایه هستند تعامل کنند. به عنوان مثال،اگر کلاس car یک کلاس پایه باشد، sportscar شاید کلاس مشتق شده از آن باشد. کلاس sportscar شاید کلاس پایه برای کلاس مشتق شده ی دیگری باشد مثل کلاس ConvertibleSportsCar. هر کلاس مشتق شده جدید، ممکن است اعضای اضافی را پیاده سازی کند، اما اعمالی که در کلاس اولیه car تعریف شده همچنان باقی می مانند.

Overloading اعضا
overloading به شما امکان می دهد که چندین عضو با نام مشابه درست کنید. هر عضوی که همنام با عضو دیگری است باید امضای متفاوتی داشته باشد. overloading متداول ترین در متدهاست. شاید شما بخواهید عضوی درست کنید که بتواند ستهای متفاوتی از پارامترها را بپذیرد.

Public Sub Display(ByVal DisplayValue As Integer)
' Implementation Omitted

End Sub

این متد کاملا پذیرفتنی است. اما فرض کنیم که می خواهید به کلاینت اجازه دهید اگر نیاز بود پارامتر duration را انتخاب کند. یا اینکه شاید بخواهید متد بتواند مقادیر integer یا string را به عنوان پارامتر DisplayValue بپذیرد. در VB.Net اجازه دارید پارامترهای اختیاری داشته باشید. چاره کار overloading است. overloadها متدهای چندگانه هستند. متدهای overload شده باید امضا متفاوتی داشته باشد. اما نیاز ندارند مقدار بازگشتی و نوع و یا سطح دسترسی مشابهی داشته باشد. وقتی متد overload صدا زده می شود ، CLR(common language runtime) نوع آرگومانهای تحویل داده شده در فراخوانی متد را امتحان می کند. این سپس لیست آرگومان را با فراخوانیها و امضاهای Overload موجود به طور مناسبی تطابق می دهد. اگر هیچ Overload ای با نوع آرگومانها تناسبی نداشته، یک خطا اعلام می شود.

درست کردن متدهای overload
شما می توانید متد overload شده را از راهی شبیه آنچه دیگر متدها را می سازند درست کنید: بوسیله توصیف متد با یک نام، یک سطح دسترسی، یک نوع بازگشتی، و یک لیست آرگومان. یک متد overload شده باید نامی شبیه متد موجودی داشته باشد. اما باید امضای متفاوتی با آن داشته باشد. سطح دسترسی و نوع بازگشتی می تواند مشابه و یا متفاوت باشد. مثال زیر متد overload شده را نشان می دهد.

' This example demonstrates an overloaded method.
Public Sub DisplayMessage(ByVal I As Integer)

MessageBox.Show(I.ToString())

End Sub

' This method has the same name as the previous method, but is

' distinguishable by signature

Public Sub DisplayMessage(ByVal S As String)

MessageBox.Show(S)

End Sub

دو متد تعریف شده، با نام یکسان اما امضا متفاوت و پیاده سازی جداگانه. وقتی یک متد با نام DisplayMessage فراخوانی می شود، تست کننده runtime نوع آرگومان تحویل داده شده را تعیین می کند. اگر یک string تامین شود. متدی که string می گیرد صدا زده می شود. اگرinteger تعیین گردید متد Integer را فراخوانی می شود.

اینترفیس‌ها:
اینترفیس یک قرارداد است. هر شئ که پیاده سازی می شود، برای تامین پیاده سازی اعضای تعیین شده در آن اینترفیس یک ضمانت نامه اینترفیس می گیرد. اگر یک شئ نیاز به تعامل با اینترفیسی داشته باشد، می تواند با آن با هر شئ‌ای که آن اینترفیس را پیاده سازی می کند تعامل داشته باشد .

یک اینترفیس فقط اعضایی را تعریف می کند که بوسیله شیی که بعدا پیاده سازی خواهد شد ساخته می شود.تعریف اینترفیس هیچ چیزی درباره ی پیاده سازی اعضا نمی دهد. فقط پارامترهای که آنها می گیرند و نوع مقادیری که آنها برخواهند گرداند.پیاده سازی اینترفیسها کاملا به پیاده سازی کلاس واگذار می شود.

بنابراین این امکان دارد که در اشیا مختلف پیاده سازی های مختلف مهیجی از اعضای مشابه داشته باشیم. به عنوان مثال، اینترفیسی به نام Ishape که یک متد CalculateArea تعریف می کند. کلاس Circle این اینترفیس را برای محاسبه مساحت خود، به طریق متفاوتی با کلاس Square پیاده سازی می کند. هر چند که یک شئ که نیاز به تعامل با IShape دارد می تواند متد CalculateArea را فراخوانی کند و هر دوی Circle یا Square نتایج درستی می دهند.

تعریف اینترفیسها
اینترفیس ها با کلمه کلیدی interface تعریف می شوند.

Public Interface IDrivable
End Interface

این اعلان اینترفیس IDrivable را تعریف می کند. ، اما هیچ عضوی برای آن تعریف نمی کند. متدهای یک عضو باید با امضای متد تعریف شود، اما بدون access modifier هایی مثل public,private. و مانند اینها. access modifier ها ی یک اینترفیسaccess modifier اعضای آن اینترفیس راتعیین می کنند.پس اگر یک اینترفیس Public داشته باشید همه اعضایش هم باید هم public باشند. مثال زیر نشان می دهد که چطور متدها را به اینترفیس اضافه کنید :

Public Interface IDrivable
Sub GoForward(ByVal Speed As Integer)

Sub Halt()

Function DistanceTraveled() As Integer

End Interface

همچنین شما می توانید خصوصیات را به اینترفیستان اضافه کنید. خصوصیت باید ReadOnly یا WriteOnly تعریف شوند. مثال زیر را ببینید.

Public Interface IDrivable
' Additional member definitions omitted

' This defines a read-only property.

ReadOnly Property FuelLevel() As Integer

End Interface

اگرچه شما می توانید خصوصیات را در اینترفیسها تعریف کنید. اما نمی توانید فیلدها را در آنها تعریف کنید. این شرط تضمین می کند که کلاسهایی که از طریق اینترفیسها تعامل دارند به دادهای درونی یک شئ دسترسی نداشته باشند. اینترفیسها همچنین می توانند رویدادها را تعریف کنند:

Public Interface IDrivable
' Additional member definitions omitted

Event OutOfFuel(ByVal sender As Object, ByVal e As System.EventArgs)

End Interface

چند شکلی با اینترفیسها (Polymorphism with Interfaces)
هر شئ که یک اینترفیس خاص را پیاده سازی می کند، می تواند با هر یک از اشیا دیگری که به آن اینترفیس نیاز دارند، تعامل کند.

Public Sub GoSomewhere(ByVal V As IDrivable)
' Implementation omitted

End Sub

این متد نیاز به یک پیاده سازی از اینترفیس IDrivable دارد. هر شئ که این اینترفیس را پیاده سازی می کند می تواند به عنوان یک پارامتر به این متد پاس داده شود. وقتی یک شئ درون اینترفیسش تعامل می کند، فقط اینترفیس اعضا دردسترس هستند. شما همچنین می توانید به طور ضمنی اشیایی که اینترفیس خاصی را پیاده سازی می کنند درست کنید. مثال بعد نشان می دهد چگونه شئ Truck اینترفیس IDrivable را طراحی می کند. (توجه کنید در این مورد Truck باید IDrivable را پیاده سازی کند).

Dim myTruck As New Truck
Dim myVehicle As IDrivable

' Casts myTruck to the IDrivable interface

myVehicle = CType(myTruck, IDrivable)

پیاده سازی اینترفیسها
در VB.net اینترفیسها بوسیله کلاسها و ساختارها (structures) با کلمه کلیدی Implements پیاده سازی می شوند.

Public Class Truck
Implements IDrivable

' Additional implementation code omitted

End Class

کلاسها می توانند چندین اینترفیس را پیاده سازی کند. اگر بخواهید کلاسی تعریف کنید که چندین اینترفیس را پیاده سازی کند، می توانید اینترفیسها را با کاماهای جدا کنید. مثال زیر را ببینید.

Public Class Truck
Implements IDrivable, IFuelBurning, ICargoCarrying

' Additional implementation code omitted

End Class

وقتی یک کلاس یا ساختاری یک اینترفیس را پیاده سازی می کند. شما باید برای هر یک از اعضای آن اینترفیس پیاده سازی جداگانه ای انجام دهید. اگر اینترفیسهای چند گانه پیاده سازی شوند، باید یک پیاده سازی برای هر عضو هر اینترفیسی انجام دهید.

پیاده سازی اعضای اینترفیسها با VB.NET
در VB.Net یک عضو کلاس با کلمه کلیدی Implements یک عضو اینترفیس را پیاده سازی می کند. عضو کلاسی که عضو اینترفیس را پیاده سازی می کند باید امضایی مشابه آن چه در اینترفیس تعریف شده داشته باشد، اما نیاز نیست که سطح دسترسی مشابهی با آن داشته باشد. مثال بعد نشان می دهد چگونه یک عضو اینترفیس تعریف می شود.

Public Interface IDrivable
Sub GoForward(ByVal Speed As Integer)

End Interface

Public Class Truck

Implements IDrivable

Public Sub GoForward(ByVal Speed As Integer)

Implements IDrivable.GoForward

' Implementation omitted

End Sub

End Class

عضو کلاسی که یک عضو اینترفیس را پیاده سازی می کند مجبور نیست که نام مشابه با نام عضو اینترفیس داشته باشد مثال بعد یک پیاده سازی کاملا بی عیب متد IDrivable از اینترفیس GoForward است.

Public Sub Move(ByVal Speed As Integer)
Implements IDrivable.GoForward

' Implementation omitted

End Sub

هر فراخوانی متد GoForward از اینترفیس در مثال قبل متد Move را از کلاس پیاده سازی می کند. همچنین شما می توانید سطح دسترسی متفاوتی را برای- متد کلاسی که متد اینترفیس را پیاده سازی می کند - در نظر بگیرید. به عنوان مثال می توانید متد Public اینترفیس را متد Private کلاس پیاده سازی کنید. اگر این روش را انجام دهید، وقتی که دسترسی درون اینترفیس است متد Public می شود، اما وقتی دسترسی به عنوان عضوی از کلاس است private می ماند.

همه مقالات آشنايی با VB.NET را ببينيد.
جستجو: بگرد!
جستجوی پيشرفته
نام کاربری |
کلمه عبور |


IranASP.NET - خداحافظ IranASP.NET!

خداحافظ IranASP.NET!

مديريت سايت | اين مقاله ۱۷۸۳ بار تاکنون ديده شده است.
۱۳۸۴/۷/۶ | برای وبلاگ برای وبلاگ
داشتم می‌رفتم ديدم بدون خداحافظی بی معرفتی است. با "مقاله" شروع کردم، با "مقاله" هم به پايان می‌برم. اگر دنبال مطلب فنی هستيد، اين مقاله آخر را نخوانيد. اگر می‌خواهيد بدانيد که چرا می‌روم، اين گفتار کوتاه را بخوانيد.

سايت‌ها آنلاين می‌ميرند.
از آبان 80 تا آبان 84. چهار سال عمر برای يک وب سايت، عمر زيادی نيست. کم هم نبود. در دنیای ديجيتال عمرها هم بمانند صفر و يک‌ها، سريع می‌گذرند و به اندازه همان صفر و يک‌ها کوچک هستند. و چهار سال دوام آوردن همه توان من بود. يکه و تنها در پستوی انديشه خود شروع کردم و به زودی همرهانی از راه دور من را همراهی و تشويق و تحسين کردند. کاری از دل بود لاجرم بر دل‌ها نشست. خود ياد می‌گرفتم و سپس زشوق ياد گرفتن آن را در اختيار ديگران قرار می‌دادم. کاری نو بود در وبستان ايرانی-فارسی و لقب اولين به آن دادند. اگر چه ديگرانی به نيکی همان راه رفتند اما آن لقب از آن خود دانستند. مبارکشان باد. هرچه بواسطه اين القاب در جيب ما رفت چند برابرش در جيب آنها باشد!

می‌خواستم کاری کنم بدون محاسبه سود و زيان و کردم آن چه دل می‌گفت و عقل را مجال ندادم. خود سيراب گشتم و برخی هم جرعه‌ای از آن برگرفته و در پايان آنچه برايم باقی مانده همگی سود است. اما نه سودی از جنس سکه و اسکناس! برعکس هر آنچه که زيان بود از جيب بود که البته از اول هم قرار بر محاسبه‌اش نداشته‌ام.

اگر ياری دوستان و همرهان نديده و نشناخته‌ام نبود، همين بضاعت اندک نيز حاصل نمی‌شد. جا دارد بدون آوردن نام، از تک تک آنها قدردانی کرده و خسته نباشيد بگويم.

اگر حمايت ميزبان خوبم ايران ميزبان (سازين سابق) نبود پيش از اينها بريده بودم. ميزبانی که به حق، حق ميزبانی را ادا کرد و اين مهمان چهار ساله را به حد اعلايش پذيرايی نمود.

اگر نبود تشويق‌ها، تشکرها، تحسين‌ها و دلگرمی‌های شما، پيش تر از اينها کار را وانهاده بودم.

و اگر نبود صبر و حوصله و ياری يار هميشگی‌ام، همسرم، اين چهار به يک هم نرسيده بود.

اينک پس از اين مدت، ديگر نه توانی برای ادامه‌اش دارم، نه وقتی و نه انگيزه‌ای. کار ناقص و نيمه تمام را هم هيچ وقت نپسنديده‌ام. مهم‌تر انگيزه است که اگر بود توانش هم جور می‌شد.

قصد بازگشت به عزلت انديشه خود کرده و مطاعی بيش از اين جهت عرضه نداشته و توان در معرض بودن بيش از اين را ندارم.عقل بر دل چيره گشته، توان و زمان تحليل رفته و عنان به سوی ديگر کشيده شده. باشد تا شايد دوباره شاهد ظفر دل باشم يا به گونه‌ی ديگری به درآيم. اگر باز به درآمدم در خدمت‌تان خواهم بود. در غير اين صورت عذر همه کاستی‌ها که کم هم نبود بر من ببخشيد.

هر آمدنی رفتنی دارد اما بدانيد که راه باز است و ديگرانی خواهند آمد و رفت و توشه‌ای همراه خواهند برد. شما هم سعی کنيد رونده باشيد و بيائيد و برويد. ماندن بر کنار جاده جز گرد و غبار روندگان شما را حاصلی نخواهد بود.

یا حق
ارادتمند شما
ساسان يگانگی

پی‌نوشت: با تشکر از اين همه لطف و حمايت و اعلام آمادگی جهت کمک و ياری توسط خوانندگان سايت، لازم ديدم تا توضيح کوتاهی را خدمت شما عرض کرده و مساله‌ای را روشن‌تر نمايم.

اينجانب هيچگاه با بيزنس پلان شروع نکرده بودم و اصولاً بيزنسی در کار نبوده که بخواهد پلانی داشته باشد تا برای آن شکست يا موفقيتی قائل باشم. مساله خيلی ساده است: بدون تعهد به هيچ کجا و هيچکس (حتی خودم) کاری از روی دل و علاقه شروع کردم و تا جائی که توانستم ادامه دادم و بهره لازم را هم برده‌ام و آنگاه که نتوانستم آن را جمع کردم. حال اگر توانستم خيری هم به ديگران برسانم که چه بهتر. از طرفی هيچگاه دنبال وام تکفا و... يا کمک ديگران و غيره نبوده‌ام و نيستم و دستم را جلوی ديگران دراز نکرده‌ام که اگر دنبال پول بودم اين قدر می‌دانم که در اين مملکت کار علمی و آموزشی ره به جايی ندارد و روش گرفتن کمک مالی از دولت يا جاهای ديگر اين نبوده و نيست. وام‌دار کسی نيستم و نخواهم بود. پس لطفاً اين قدر چوب بيزنس پلان و سواد تجاری و بازاريابی خود را بر سر من نکوبيد. من يک برنامه نويس خيلی معمولی بدون سواد تجاری و بيزنس پلان و روابط خاص هستم و احتمالاً همان هم خواهم ماند. لطفاً دقت کنيد که من در متن فوق و نه هيچ کجای ديگر هيچگاه نگفته‌ام که شکست خورده‌ام يا حتی دنبال راه حل جهت احيا سایت هستم. هر آغازی دير يا زود پايانی دارد و پايان اين سايت امروز رسيده است. مشکل ما ايرانی‌ها اکثراًً اين است که بدون دقت در گفتار گوينده يا نويسنده خيلی زود ژست منتقد ويرانگر را به خود می‌گيريم و اصلاً هم قائل به اين مساله نيستيم که طرف ممکن است فکر و تعقل و دليل هم برای کار خود داشته باشد و يکسره وی را با چوب بی‌کفايتی، عدم تعقل و شعور، بدون برنامگی و... می‌رانيم. نه تصميم تعطيلی سايت به زعم بعضی دوستان يک شبه بوده و نه تصميم راه‌اندازی‌اش، بلکه حدود يک الی دو سال است که برای اين کار با خودم کلنجار رفته‌ام.

باز هم از همه شما عزيزان که نامه و مطلب نوشتيد و به شکل‌های مختلف حمايت خود را ابراز داشتيد بی‌نهايت متشکرم.

اگر مطلبی می‌خواهيد اضافه کنيد، در اينجا بنويسيد و بفرستيد. سعی می‌کنم آنچه را که می‌شود، با ذکر نام فرستنده در زير اين مقاله بياورم.

نظرات شما:

محمد جواد سخائی: خبر تعطيلی سايت IranASP.NET را همانند ساير دوستان و همكاران شنيدم و از شنيدن آن سخت ناراحت ، چراكه انسان از خاموش شدن هر نوع چراغ دانشی ناراحت خواهد شد، خصوصا" در اين مقطع زمانی كه حداقل همه دوست دارند داناتر از ديروز باشند .به نظر شما ما در ايران دارای چندين سايت توليد كننده محتوی می باشيم ؟ پاسخ به سوال فوق علت نگرانی تمامی علاقه مندان به عرصه فن آوری اطلاعات و ارتباطات در خصوص تعطيلی سايت ارزشمند IranASP.NET را به خوبی نشان می دهد . و اما حقايقی در رابطه با سايت IranASP.NET - سايت IranASP.NET اولين سايت آموزشی فارسی در عرصه وب می باشد كه در عمر كوتاه خود توانسته است منشاء تحولات فراوانی گردد و سايت های ديگر با الگو برداری از آن ايجاد شوند . - سايت IranASP.NET به درستی فعل " ما می‌توانيم " را با حداقل امكانات و حداكثر بهره وری و بدون هيچگونه ادعائی در اين مرزو بوم صرف نموده است . - سايت IranASP.NET توانست برای اولين مرتبه فرهنگ كار گروهی جهت نيل به اهداف علمی را در اين مرزو بوم و در اين عرصه جديد عملی نمايد . - سايت IranASP.NET توانست حضوری افتخار آميز در عرصه بين المللی داشته باشد و پذيرای مخاطبان بسيار زيادی از اقصی نقاط جهان باشد . جملگی می دانيم جذب حتی يك مخاطب در اين عرصه با وجود هزاران سايت قدرتمند آموزشی در جهان چقدر مشكل می باشد . - سايت IranASP.NET توانست نه يك تكنولوژی خاص بلكه يك فرهنگ جديد در عرصه وب را ترويج نمايد . كوته فكری است اگر تصور كنيم كه اين سايت به دنبال تبليغ يك تكنولوژی خاص بوده است . در بطن اين حركت ، واقعيتی بزرگ نهفته است كه جزء با چشمانی تيزبين و آينده نگر نمی توان آن را مشاهده نمود . - مديريت سايت IranASP.NET جناب آقای مهندس يگانگی توانست به اين افتخار نائل شود كه در اين هنگامه خود محوری افراطی ،‌ چهار سال از بهترين زمان عمر خود را صرف اين كار نمايد تا حركت وی برگ زرينی باشد از تجلی "شدن" و انصافا" كه اين رسالت را به بهترين صورت ممكن انجام داده است . به نظر شما ارزش يك ثانيه از عمر انسان چقدر است ؟ - مديريت سايت IranASP.NET، عاشق بودن در عرصه كار علمی را به نحو احسن به ما نشان داد . عشقی كه می بايست در راه آن از خيلی چيزها گذشت كرد و از شعارهای جذاب فاصله گرفت . - مديريت سايت IranASP.NET بيش از سهم خود در راه اعتلای علمی كشور گام برداشته است . تصور كنيد ايران با جمعيت چندين ميليونی خود و داشتن هزاران عاشق چون ايشان به چه جايگاه علمی در عرصه بين المللی می تواند دست يابد . مظلوميت تمامی سايت های توليد كننده محتوی - تمامی شواهد موجود بدون هيچگونه شك و ترديدی حكايت از مظلوميت تمامی‌ سايت های توليد كننده محتوی فارسی در عرصه وب دارد و می بايست همواره در انتظار اينچنين اخبار نگران شده ای بود . - افرادی‌ كه در ميادين علمی تلاش می نمايند به حداقل هائی بسنده می نمايند . چرا ما نمی توانيم حداقل های آدم های بزرگ را تامين نمائيم ؟ پيشرفت علمی هر كشور مديون تلاش همين آدم های بزرگ است و عدم تامين حداقل خواسته های آنان پيامدهای بسيار منفی را در ابعاد ملی به دنبال خواهد داشت . حداقل آن ، ‌بی تفاوتی است و بی انگيزه كردن افرادی است كه در بدو ورود به ميدان خود منبع سرشار انگيزه ديگران بوده اند . - متاسفانه ما در برخی موارد از روش های منطقی برای نفی‌ و يا اثبات ديگران استفاده نمی كنيم . كافی است به برخی از نظرات دوستانی كه در ذيل اين مقاله منعكس شده است مراجعه نمائيد تا مواردی‌ از اين قبيل را مشاهده نمائيد . افرادی‌ كه ندانسته از چيزی دفاع می كنند با افرادی كه ندانسته با چيزی مخالفت می كنند در يك نقطه حياتی با يكديگر مشترك هستند و آن صرف فعل " ندانستن " است . سايت IranASP.NET با معرفی برخی از تكنولوژی های شركت مايكروسافت اين فرصت را در اختيار مخالفان قرار داده است كه آگاهانه با آنان مخالفت نمايند. خوب است مخالفت با هر چيزی مبتنی بر منطق و رويكردهای علمی باشد . سايت IranASP.NET از اين زاويه نيز اقدامات برجسته ای را تاكنون انجام داده است و دليلی ندارد كه برخی دوستان از خبر تعطيلی آن خوشحال گردند! و اما يك پرسش از دست اندركاران برنامه تكفا آيا بند "و" ماده سه آيين نامه اجرائی تبصره سيزده قانون بودجه در رابطه با طرح گسترش كاربری فن آوری اطلاعات و ارتباطات در قلمرو فرهنگ و هنر ، تعريف خط و زبان فارسی در محيط رايانه ای ، تا كنون مصاديقی نيز داشته است و به افراد يا سايت هائی كه در موارد اشاره شده فعاليت می نمايند ، تعلق گرفته است ؟ دوستان حداقل شما می توانستيد از اينگونه حركات جوان و خودجوش در كشور حمايت معنوی نمائيد . و اما برای آينده زمانی كه برخی از دوستان برای شركت يك ساعته خود در جلسه ای توجيه مادی آن را دنبال می نمايند، چگونه می توان توقع داشت كه افرادی هزاران ساعت وقت خود را در بدون هيچگونه حمايت معنوی و يا مادی درراه اعتلای دانش فن آوری اطلاعات و ارتباطات صرف نمايند . آقای مهندس يگانگی كه ناتوان در انجام كار و وظايف از قبل تعريف شده خود نمی باشد قطعا" با رويكرد فعلی و آزاد شدن زمان ،‌ وی فرصت بيشتری برای نيل به اهداف خود را پيدا می نمايد و موفقيت شخصی وی تضمين شده است . ولی بيائيد صادقانه به اين پرسش پاسخ دهيم كه هزينه تربيت يك نفر عاشق در اين مرز و بوم چه ميزان است و هزينه بی انگيزه كردن عاشقان چه ميزان است ؟ به نظر شما ما در كدام بخش هزينه كرده ايم ؟ و اما سخن پايانی افتخار می نمايم كه در بدو راه اندازی سايت IranASP.NET همكاری خود را با آن آغاز كردم و اندك اطلاعات موجود را در طبق اخلاص نمودم چراكه استادی را يافته بودم كه مدت ها آن را در ذهن خود مجسم می‌ كردم و به دنبال آن در خواب و رويا بودم . استادی كه شهامت توانستن را در وجود من زنده كرد و شايد به همين دلايل باشد كه پس از گذشت چندين ساعت از راه اندازی سايت IranASP.NET اولين مطلب را برای آن ارسال نمودم . چه سخت است سخن به پايان بردن ولی دوست و استاد بزرگوار جناب آقای مهندس يگانگی حيات ماهی به آب است و ماهی بدون آب توان زندگی را ندارد . آدم عاشق نيز نمی تواند بدون عشق زندگی كند . مطمئن هستم كه دگر باره عشق بر عقل چيره خواهد گشت و در سنگری‌ ديگر آثار آن هويدا خواهد شد . تا آن روز نزديك بی صبرانه منتظر می مانيم تا درسی ديگر را بياموزيم و تجربه ای افزون نمائيم .

توحید: سلام. آقا مثل اینکه مرغ یه پا داره، هان؟ :) بابا جان به حق این وقت عزیز از ماکسیمای شیطون بیا پایین... می ترسی بگن یارو از سر شکم سیری رفته بود که نرفته برگشت؟ بلا نسبت شما به .... [...]! (خداوکیلی سمج تر از من دیده بودی؟ :)) مخلص، -توحید

Siamak: salam mibakhshid ke man intor minevisam, chahas saale pish man ba in website ashnaa shodam sharmande am ke dinaari be aan komak nakarde am va narahatam az inke intor tanhaa mishavim dobare websitehaie khoob daane daane kerkereha ra paieen keshidand o raftand o maa mandim o iek donya bisavadi harja ke hastid movafagh bashid heif shod in avakher sitetaan dasht hesaabi paaa migereft koli moshtari shode boodim, pirooz bashid o hamintor sakht koosh

نوید خلیلی: با سلام و تشکر فراوان به خاطر این 4 سال و اندوه با خاطر رفتن شما پس از اینکه این خبر را شنیدم واقا متاسف شدم ، چون به نظر من شما اولین و بهترین سایت آموزشی در مورد asp.net بودید . من که از مقالات آموزشی شما بسیار استفاده کردم و از شما سپاس گذار هستم. امید وارم که از تصمیم خود صرف نظر کنید و همه مخاطبان خود را خوش حال کنید . با آرزوی پیروزی و موفقیت برای شما و تشکر به خاطر زحمات شما در این مدت . نوید خلیلی www.irstarnet.com

zaman: خیلی متاسفم من خودم php کار می کنم ولی می خواستم در کنارش تازه asp کار کنم پس باد متاسف باشم واسه خودم چون از اطلاعات یک سایت خوب بی بهره می شم در پناه حق باشید

آرش ميکائيلی: من مدير سايت iranphp.net هستم و به نمايندگی از طرف بچه های IranPHP به شما خسته نباشيد می گم و اميدوارم که در راهتان موفق باشيد.با اينکه تا به حال از سايت شما استفاده نکرده بودم با شنيدن خبر توقف فعاليتتون دلم گرفت در هر صورت اگر راهی برای ادامه اين فعاليت وجود دارد و يا کمکی از دست ما بر می آید لطفا با من تماس بگيريد بلکه خدمات با ارزش شما همچنان ادامه پيدا کند. موفق باشيد.

رسول هاجري: سلام قبل از هر چيز مي خواستم از زحمات چند سال اخير شما در اين سايت تشکر و قدرداني کنم. به هر صورت هيچ کار خوبي در اين هستي حتي به هر اندازه کوچک از بين نمي رود چه رسد به زحمات فراوان و مخلصانه شما . اميدوارم در تمام مراحل زندگي خود موفق باشيد. ولي از آنجايي که به هر صورت سايت حاضر بخشي از زندگي و عمر گرانقدر شما را تشکيل داده است به نظرم آنرا حفظ نماييد و حتي اگر لازم است جلسه ای تشکيل دهيد و از همه دوستاني که مقاله فرستاده بودند نيز دعوت نموده و در رابطه با نحوه ادامه کار سايت به صورت جمعي با همان سردبيري شما بحث و مشورت کنيم. در هر صورت آرزوي موفقيت شما را در تمام مراحل زندگيتان دارم.

نيما حقاني: سلام رفيق خوب كارت عالي بود . ولي مي خواستم ببينم تكليف اين سايت چي مي شه درش رو تخته مي كني ؟ مي توني به من بديش ؟ من ادامش مي دم . من يك برنامه نويس حرفه اي با پشتكاره عالي هستم . اجازشو به من مي دي ؟ اگه خواستي با موبايلم تماس بگير...

مجيد صادقي: سلام ساسان جان سخت ترين خبري بود که شنيدم.. واقعا بهت حق ميدم... و درکتم مي کنم.. خودم کشيدم... نه از نظر مالي ، بلکه از تمام جهات.. راستي اگه بشه که تمام مقالات موجود رو تو يه PDF به زنيد و بزاريد تو سايت خيلي خوب ميشه.... اينجوري بعد از بسته شدن سايت بازم ميشه به مطالب دست رسي داشت.. با تشکر

ميلاد: اصلا من از asp.net به شدت بدم مياد ولي بدونيد كه اين اصلا باعث نمي شه كه از رفتن شما خوشحال بشم حذف شدن يك منبع فارسي در وب اون هم چنين سايت پرمطلبي مثل شما خيلي نارحت كننده است

حمید: این مقاله آخر رو خوندم مثل بقیه مقاله ها . نظرات رو هم خوندم. هر کس به زعم خودش یه چیز هایی نوشته . تقریبا 3 ساله دارم برنامه نویسی می کنم .همون اوایل بود که با Iranasp آشنا شدم . یادمه که اولش گاها .com می زدم می رفت به همون سایت فلش دار! الان 3 ساله که دیگه هیچ وقت اشتباه نکردم.( در مورد .com )خیلی چیزا ازش یاد گرفتم . خوب تا همین حالا بهتون بگم که خیلی خیلی دستتون درد نکنه . هیچ سایت فارسی ( لااقل ) در زمینه برنامه نویسی سراغ ندارم که اینقدر کارش درست باشه . وقتی این همه تبلیغات رو توی کشور میبینی که همه دم از IT و تکفا و این حرفا می زنن اونوقت iranasp داره تعطیل می شه و پیشگامان صنعت IT کشور( الفاظ گنده گنده ) هم ککشون نمی گزه دیگه اون توجیه کردن اینکه بابا ما تو مملکت دنبال علم و پیشرفت هستیم واقعا برات جوک خنده داری میشه ( البته شده بود، حالا خنده دار تر) . اگه iranasp تعطیل بشه مگه چه اتفاقی میفته . نفتمون که تموم نشده فعلا هست . شورش یا تظاهراتی هم که نمیشه .زندگی هم که به آخر نرسیده ، بنده هم که هنوز هستم پس اکشال نداره تعطیل بشود یکی جدیدش را می زنیم . اصلا بگذار تعطیل بشود. این iranasp داشت محصول بیگانه را تبلیغ می کرد.آن هم آمریکای شیطان و نوکر آن مایکروسافت . ما اصلا به آنها نیاز نداریم ما خودمان داریم سیستم عامل می زنیم . خیلی هم هالیمان است .چندین میلیون هم خرجش کردیم فردا پس فردا هم یک شرکت میزنیم و این سیستم عامل را هم به کشور های جهان ( کشورهایی مثل پاکستان ، ارمنستان ، بورکینافاسو و سوریه و لبنان داخل پارانتز با پول و رشوه و زورکی ) صادر خواهیم کرد. سخن کوتاه من هم همانند سایر دوستان اگر از دستم بر بیاد حاضرم همکاری کنم . به هر حال اگر رفتید بدانید که کار بزرگی کردید. ما چشم انتظار بازگشت دوباره شماییم . ممنونم ساسان یگانگی به خاطر همه آن چیزهایی که یاد گرفتم .

حامد سعیدی فرد: مثل دیگرانی که قبل از من در مورد آخرین مقاله این سایت نظر داده اند، باید از شخص شما آقای یگانگی تشکر کنم. جدا که خسته نباشید. این سایت یک سمبل فراموش نشدنی برای همه ما خواهد بود. شاید روزی بار دیگر در سایت ها و وبلاگ هامان خبر بدهیم که IranASP.net برگشت. به هر حال برایتان بهترین آرزوها را دارم هم از طرف خودم و هم از طرف صدها جوانی که این سایت الگو و مرجعشان بوده است. در پناه حق

امین: با سلام و خسته نباشید، واقعا از شنیدن این خبر ناراحت شدم.امیدورام هر کجا هستین شاد، سلامت و سربلند باشین. انشاالله کارهای بهتری از شما ببینیم

مائده: سلام خبر تعطيلي سايت براي من هم شوك آور بود. اصلا انتظلرش را نداشتم. ميدانم كه خيلي وقتها خستگي به هر كسي ممكنه كه رو كنه .شما هم بعد از اين مدت خسته شدين. يه پيشتهاد دارم چرا سايت را به كسي که هنوز تازه نفسه نفسه نمي سپرين؟سايت خوبي دارين.واقعا حيف كه بسته بشه.

iflashdes: خبر تعطيلي IranASP.net با عنوان "سايتها آنلاين مي ميريند"، انعكاس گسترده اي در بين كساني كه كاربر اين سايت بودند و يا حداقل اون رو مي شناختند ، پيدا كرده، كه البته خود من هم از اين قاعده مستثني نيستم. با ديدن متن خداحافظي آقاي يگانگي واقعا ناراحت شدم، و تاسف خوردم. براي چه كسي؟ براي آنهايي كه با مديريت غلط، كساني كه در عرصه فناوري اطلاعات با جان و دل فعاليت مي كنند را نا اميد مي كنند. به كساني كه با صرف بودجه هاي ميلياردي ادعاي پيشبرد فناوري اطلاعات در كشورمون رو دارند ولي از نتيجه خبري نيست! يك سايت آموزشي كه هر مقاله آن را به صورت ميانگين حدود 1800 نفر مي خواندند، بايد با نااميدي مدير آن از هرچه كه اميد داشت به راحتي تعطيل شود!‌ كيست كه پاسخگو باشد ؟ خدا را شكر ميكنيم كه تخصص بعضي ها در اين حد نيست كه بتوانند براي تعطيلي اين سايت نظرات پروفسور مئابانه خود را تحويلمان دهند. به هر حال آخر كار ديگر دير است بايد فكري به حال خودمان بكنيم ، بايد يكديگر را پشتيباني كنيم تا ديگر از اين اتفاقها برايمان نيفتد ، به اميد آن روز ... (لينک)

بابک: سلام دوست عزیز وقتی نامه خداحافظی شما رو در سایت خوندم بسیار بسیار ناراحت و نگران شدم. ناراحت از اینکه یه چرا باید عاقبت همه دوستانی که توی نت خدمات اینچنینی ارائه می کنند این باشه و نگران از اینکه نکنه شما بخواهید این سایت رو تعطیل کنید. این میل رو برای شما فرستادم تا یک پیشنهاد رو دوستانه بررسی کنیم : اگر واقعا به دلایل شخصی میخواهید این سایت رو کلا محو کنید که هیچ ولی اگر دوست دارید زحمتی که در این چهار سال کشیدید به فراموشی سپرده نشه و و این سایت همچنان مرجع کامل ایرانی های علاقه مند به فراگیری باشه من پیشنهاد می کنم این سایت رو بفروشید. من خودم حاضر این سایت رو از شما بخرم با این شرط که هر زمان که شما خواستید بر گردید و توانایی ادامه رو داشتید به شما پسش بدم. دوست دارم این چراغ روشن بمونه. متنظر جواب شما هستم.

حسین روزنامه چی: سلام ، نمیتونم بهت بگم نرو با اینکه خیلی دلم میخواد! چقدر خوشحال شدم وقتی دیدم یک مقاله جدید اضافه شده ، حیف که حتی چند ثانیه هم طول نکشید! می‌خوام فقط بدونی امروز یاد اولین باری افتادم که توی عشق شکست خوردم،آره ایندفعه دیگه شبا بی خوابی نمیکشیم ، از غذا نمی افتم ! ولی حالم گرفتست ! حال خیلی‌های دیگه هم گرفتست ! میدونی من اینجا خیلی خاطره دارم مثلا وقتی اسم سایت رو کنار سایت رسمی asp.net زده بودند رو یادته چه افتخاری میکردم ! من خیلی وقته با این سایتم از همون اولاش ! این سایت عصای من بود وقتی از کوه دات نت بالا میرفتم !حالا شاید دیگه خودم بتونم بقیه راه رو برم ولی وقتی یکی اون پایین ازم می پرسه منم میخوام بیام بالا چی بهش بگم ؟ (نمیدونم برو تو گوگل سرچ کن ؟!) حالا اراده کردی و راه افتادی دیگه بهت نمیتوم بگم برگرد فقط میخوام ازت خواهش کنم لا اقل یه فکری به حال آریشو سایت بکنی ! میدونم که خسته‌ای میدونم که داری میری ! ولی به خاطر این همه قلب هایی که تا اینجا دنبال پرچمت اومدن ، اگه نمی تونی دیگه زحمت حمل کردنش رو بکشی لااقل پرتش نکن روی زمین (پرچمی رو که دست کم ما میدونمی "فروشی نیست !!!")! و میخوام ازت تشکر کنم به خاطر همه عشقی که به دات نت دارم !

مريم: از دیدن مقاله خداحافظی شما واقعا شوکه شدم. سایت شما برای من خیلی مفید بود. به هر حال از سایت بسیار خوبتان تشکر می کنم. موفق باشد.

ياسر بتويي: بهترين ها مي روند بهترين شدي و بهترين راه را انتخاب كردي چرا كه امكان اين مي رود ديگر تحليل مي روي و كار بهتري نمي تواني انجام بدهي . تو اين چهار سال دانش نيافريدي انسان تربيت كردي چرا كه بعد از تو يكي ديگر راهت را ادامه مي دهد و اين نسل به نسل مي گردد. آرزوي عاقبت بخيري شما عزيزان .

جمشيدي: سلام آقاساسان . از اين كه ديگه نمي خواهيد سايت رو ادامه بديد متاسفم اما پيشنهادي دارم . آيا حاضريد امتياز سايت رو واگذار كنيد؟ تمام محتويات نام دامنه و هاست رو؟ اگر مايل بوديد لطفا نظرتون رو درباره شرايط واگذاري و مبلق پيشنهادي تون رو برام بفرستيد. ممنون.

حمید: سلام 4 سال تلاش بی وقفه و امیدوار کننده شما دوست عزیز و برنامه نویس فعال را می ستایم باشد. پس از شنیدن بسته شدن سایت IranASP.NET بسیار ناراحت شدم و نظری دارم حال که شما می خواهید بروید یک جانشین برای خود بیابید. من که حدود دو سال است ASP.NET را فرا میگیرم حاضر به همکاری با شما برای ادامه روند فعالیتی سایت می باشم. با تشکر

اکرم حمزه: جناب آقای یگانگی آنتونی رابینز می گه: همیشه با "چگونه" برای پیدا کردن "راه حل" مشکلات جملات را سوالی کنید؟ نه با "چرا". چگونه می توان IranAsp.net را احیا کرد؟ آیا این سوال برای عنوان آخرین مقاله(تان) بهتر نبود؟ من 5/2 سال پیش زبان برنامه نویسی پایان نامه کارشناسی ام Asp.net بود و با این سایت هم آشنا نبودم. شما نمی دونید چقدر زجر کشیدم (!!!) ولی وقتی یک سال پیش با سایت شما آشنا شدم از ذوق و خوشحالی اونو به هر کس که دوستش داشتم و براش آرزوی موفقیت داشتم، معرفی می کردم و خودم با اینکه در این مدت با زبان دیگری کار می کردم، ولی مدام سایت شما را چک می کردم و تنها به "امید" و "ذوق" آن و مقاله های زیباش برای ادامه یادگیری Asp.net تلاش می کردم. به من الهام شده شما می تونید یه راهی پیدا کنید. با آرزوی موفقیت

علي: با سلام (به نظر من ) شما توانستيد شوري را كه در دل داريد به شعور تبديل كنيد و چهار سال اين سايت را سر پا نگه داريد. ولي از آنجا كه هيچ سياست مالي در پيش نگرفته بوديد به قول خودتان شكست خورديد. دوست عزيز بهتر است اين را از چشم خودتان ببيميد نه جامعه و فرهنگ و حمايت و .... شما كه قبلا مي دانستيد هيچ يك از اينها شايد در ايران به زودي بوقوع نپيوتدد پس چرا تعقل لازم را نكرديد. به بن بست هم نرسيده ايد. بهتر است براي برگشت چيزي نگه داريد(غزل خداحافظي را بس كنيد) و علل شكست خود را بازبيني كنيد و با تعقل بكار آييد و با دل و عشق كار كنيد. اين همه برنامه نوشتيد هنوز جالب است كه نفهميديد كه هميشه يك راحي است با تشكر

احسان پگاه: صحبت از خداحافظی همیشه تلخه...مخصوصا خداحافظی از یه عشق، عشقی که فقط کامپیوتری ها ازش سر در میارن...اما آیا راهی وجود نداره که سکان سایت رو به دست دوست یا آشنایی بدید که بتونه همچنان سایت رو به روز نگه داره ؟ من با اینکه همکاری خیلی ناچیزی با سایت داشتم اما مثل خیلی های دیگه سایت رو از خودم میدونم و با تموم وجود دوسِش دارم... ارادتمند، احسان پگاه 1384/7/9

mohamad reza: salam....aval tashakor mikonam bekhatere zahmate gozashtatoon..bad arz mikonam khedmatetoon ke vaghean bekhoda ghasam delam gereft didam website tatil shode...bavareton mishe ashk too chesham jam shod ? nemidoonam chera ama man az kasaii hastam ke sob ta shab paye computer hastam o vs.net o delphi o ela akhar...man dashtam dadashe website shoma ro tarahi mikardam ke hamoon iransql.com hast...chize ziadi ta rah andazish namoonde...jenabe sasani hadafe ma chie ? sar boland kardane name keshvaremoon...hamin ke esme site shoma too site microsoft be onvane marjae farsi zabane asp. bood koli eftekhar hast vase ma..hala daghighan vaghty too oje kar boodin mashino too dande khamoosh kardin,\. chera ? vaghean asp.net tamoom shod ? man chi kar mitoonam konam ? lotfan behem begin

Jannesari: متاسفم و غمگین اگر میشه نرید

امیر حسین جدیدی نژاد: سلام قبل از هر چیز, به خاطر همه این 4 سال زحمت و تلاش از شما و همه دوستانتان تشکر می کنم. مسلما تنها کسانی که تجربه این کار را داشته باشند درک می کنند که 4 سال تمام به روزرسانی یک سایت تخصصی یعنی چه هجمی از تلاش و زحمت و تخصص. به نظر من IranAsp.NET در تمامی این سال ها, رسالتی را که به عهده داشت به خوبی انجام داد. امیدوارم همیشه موفق و موید باشید. Chortke.NET

همايون اسلامي: مي دانم كه گرداندن سايت، در شرايط فعلي، چه اندازه سخت، و از نظر مادي، چه اندازه بي معني است؛ اما اميدوارم به حضور مجازي خود، ادامه بدهيد.

عليرضا شيرازی: مرثیه ای برای یک سایت

مهدی تقی‌زاده: سايتها آنلاين می ميرند!

حميد استادهاشمي: سلام ساسان عزيز. بسيار متأسف شدم وقتي خبر تعطيلي اين سايت رو شنيدم و به چشم ديدم. 4 سال پيش كه IranASP.net پا گرفت خيلي خوشحال شدم و تنها كمكي كه از دستم برميومد ارسال مقاله به سايت بود. موفقيت تو دلگرمي ما شد. با شور و شوق زياد با بچه هاي ديگر Persianlearn.com را راه انداختيم. اما پس از كمي فعاليت، مشكلات هميشگي. عدم حمايت و پشتيباني. خيلي قدرت مي خواست كه 4 سال دوام بياري. مي دونم خيلي سخته اما هيچ كس نمي خواست و نمي خواهد امثال اين سايت ها تعطيل بشن و سايت هايي كه هيچ ارزش محتوايي ندارند جون بگيرن. به هر حال اميدوارم موفق باشي و اميد به آن روز دارم كه دوباره در اين دنياي مجازي با كاري نو و موفق ببينمت.

پرويز زاهد: يک بخش از ماجرا به خودتون بر ميگرده . . .صبرتان تمام شده در حالي که فاصله زيادي با هدف نداشتيد . . يعني بايد ديد شما چه مدل تجاري داشتيد که به هدف آن نرسيده ايد؟ مشکل از بيزنس پلان شماست. شما کاري خدماتي و بدون بهره را انتخاب کرديد و بهره هم نبرديد . . . اين طبيعي است. فکر مي کنم چاره اش در اين است که مدل کارتان را تغيير دهيد و از سايت سرويس صلواتي به تيم کاري و حرفه اي که قطعا در مقابل دريافت وجه سفارش مي گيرد کار کنيد . . . بعدش مي تونيد خدمات اطلاع رساني صلواتي را نيز سرپا نگهداريد . .موفق باشيد . . مطمئن هستم با سيستمي ديگر و با استفاده از اين تجربه 4 ساله بر خواهيد گشت

وحيدرضا سليمان: سلام. الان ساعت يك بامداد شنبه 9 مهرماه هست كه خبر تعطيلي اين سايت را در سايت خبرچين ديدم. آمدم و مقاله آخر شما را خواندم. خوب. شايد بتوان كمي به شما حق داد. اما نكته اي كه مي خواستم عرض كنم اين است كه ميخواهم هرآنچه كه از دستم برمي آيد در جهت راه اندازي مجدد اين سايت فراهم كنم. من مدير عامل شركت نرم افزاري مسير فن آوري اطلاعات هستم و به طور رسمي از شما دعوت مي كنم كه طي يك ديدار حضوري به مشكلات موجود پرداخته و به دنبال راه حل آن باشيم تا بتوانيم مجددا سايت را احيا كنيم. منتظر پاسخ شما هستم.

سامان: من هم از این خبر نهایت اندوه خود را اعلام می کنم چون مدت زیادیه که با این سایت و مقالات آن آشنا شده و از ان بهره مند شده ام در وحله اول اگر امکان دارد این کار رانکنید در وحله دوم اگر این تصمیم را داشتید چون این وب سایت مقالاتی غنی رو در خودش جای داده من حاضرم در سایت خودم همه مقالات رو با ذکر نام نویسندگان و وب سایت iranasp.net قرار دهم تا حداقل آرشیوی از این زحمات جای مانده در اختیار افراد تازه کار دیگری نیز قرار گیرد

دکتر توحید عزیزی: دو پلیت را روبروی پرستار گرفتم، اما فقط روی یکی از آنها ژل ریخت. پلیت ها را به هم مالیدم و به صورت دختر نگاه کردم: احتمالا پرونده اش را اشتباه پر کرده بودند؛ قیافه اش خیلی کمتر از 20 سال نشان می داد. گفتم: «سیصد» و بهیار پیچ دستگاه را تا آخر پیچاند. پلیت چپ را در قسمت راست استرنوم بین دو سینه اش و پلیت راست را زیر و خارج سینه چپش گذاشتم و با اینکه احتمال نمی‌دادم کسی به تخت چسبیده باشد، داد زدم: «جدا» آخرین شانسش بود. 30 دقیقه از شروع سی.پی.آر می گذشت و دو بار شوک گرفته بود. اگر با این شوک هم بر نمی گشت، دیگر امیدی نبود. دکمه های روی پلیت ها را با دو شستم فشار دادم. سینه هایش بالا پرید. همه به مانیتور خیره شده بودیم. چیز جدیدی جز همان فلات لاین قبلی دیده نمی‌شد. نمی‌دانم چرا این چیز ها را نوشتم. وقتی اتفاقی خبر را در وبلاگ یکی از دوستان خواندم و سراسیمه ایران.ای.اس.پی را باز کردم، ناخوداگاه یاد این خاطره‌ی بد افتادم. شاید شوک ناشی از تعطیلی وب سایت مرا یاد آن شوک الکتریکی انداخت. نمی‌دانم، نمی‌دانم. و نمی‌دانم دیگر چه باید بنویسم. نوشته های ما بقی دوستان را خواندم. حق با آنهاست، حق با توست. به دستور ما نیامده بودی که بخواهی با اجازه‌ی ما بروی. اگر چه همه فکر می کریدم که IranASP.net نه وب‌سایت تو، که وب پناه همه است و وبمستر و ویزیتوری در کار نیست، ظاهرا اشتباه کرده بودیم. خب رسما و قانونا هم اینجا مال خودت هست. خود خودت. می‌توانی بازکنی، ببندی، عوض کنی، اصلا همه اش را پاک کنی و تبلیغ داروهای دراز کننده‌ی آن عضو را بگذاری! خب مال خودت هست دیگر، مگر نیست؟ اصلا این فضولی‌ها به من نیامده. خبر مرگم پزشکی خوانده ام، مرا چه به ASP.net؟ وب‌سایتش را همیشه می‌خواندم؟ ببخشید، دور از جان شما، انیمال استول اضافه می‌خوردم! دوستش داشتم؟ غلط کرده بودم! عاشقش شده بودم؟ برو بابا عشق کیلو چنده! یک کلام: آره! یعنی همان «بلی» خودمانی! آره اینها هیچ کدام به هم مربوط نیست و از همه کمتر به من مربوط است. من که حتی سواتم(!) نمی‌کشید یک مقاله‌ی یک صفحه ای راجع به یک کوفتی بنویسم و بفرستم تا امروز بتوانم ادعایی داشته باشم. بله، من هیچ که هیچ، از هیچ هم کمتر محل اعراب دارم و نمی‌دانم این همه را دارم با کدام رو و کدام اجازه می‌نویسم. اما می‌خواهم بدانی، تو که صاحب وب‌سایت iranasp.net بوده ای و هستی، بدانی که عجیب دلم را شکستی، مثل همان دختری که دلم را شکست و احیا نشد! لامصب تو که در کما نبودی، لا اقل لب باز می‌کردی و می‌گفتی داری می‌میری (بلا نسبت شما، منظورم وب‌سایت است)، ما یک خاکی بر سر خودمان بریزیم، چه می‌دانم، تیم CPR را خبر می‌کردیم، سرم می‌آوردیم، رگ می‌گرفتیم، اینتوبه می‌کردیم، تنفس مصنوعی می‌دادیم، مالش قلبی، بالاخره یک تلاشی می‌کردیم. نه هیمنطور دست بسته و منفعل (الان دلم میخواهد یک مشت بزنم به این دیوار کناری...) آقا جان، کسی مقاله نمی‌داد، خب می‌گفتی من هر شب برایت مقاله می‌دادم. نقش ASP.NET در درمان لوکمی حاد! چگونه پزشکی را به دات نت 2 ارتقا بخشیم. اساس اورژانس‌های ASP.NET. بهتر از اینها؟ پول کم آورده بودی، با این چندغاز که نمی‌شود رشوه داد و سربازی را خرید(!)، می‌دادیم برای وب‌سایت. اصلا راه میفتادم دور اینترنت و از ایرانی و خارجی گدایی می‌کردم (در این موارد خارجی‌ها بهتر از هموطن‌ها هستند! بالاخره 1 دلارشون 10000 ریال می‌شه!) آخر اینجوری Sudden death که نمی‌شود! بک اعلامی، علامتی، نشانه‌ای، آزمایشی، چیزی... اگر از من می‌پرسی، هنوز مرگ حادث نشده است (ایضا منظور همان مرگ وب‌سایت iranasp.net است که به قول شما آنلاین می‌میرد.) اصولا اگر آنلاین باشد که مرگ نیست. یعنی در پزشکی GCS=3 (عدم تحرک، عدم پاسخ، و عدم صحبت) مرگ نیست، Deep coma ست. یعنی هنوز امید به بازگشت هست. بیا مرام بذار و امید ما رو ناامید نکن. ما در بست در خدمتیم. مخلص دکتر توحید عزیزی

عارف: من تازه asp.net رو شروع کرده بودم که با سایت شما آشنا شدم و کلی حال کردم دیدم به چه خبره کلی مقاله درست وحسابی اینجاست پیش خودم گفتم دمشون گرم عجب سایت جون داریه کلی مقاله گرفتم اما الان که این خدا حافظی رو دیدم حالم گرفته شده اگه برات امکان داره بمون منم چیز زیادی بلد نیستم که بدرد بخوره که بگم می تونم کمک کنم ولی یه تقاضا دارم اگه می تونی بمون و ما رو تنها نزار

الهام: جناب آقای مهندس یگانگی خبر تعطیل شدن سایت شما واقعا یکی از ناراحت کننده ترین خبرهایی بود که خواندم. متاسفانه من خیلی دیر با این سایت آشنا شدم ولی در همین مدت کوتاه مطالب بسیار مفیدی از سایت شما دریافت داشتم و الان احساس می کنم که یکی از معلمین خوبم را از دست می دهم.هر چند که آگاهی من در زمینه ASP.NETدر مقابل اطلاعات شما بسیار بی مقدار است با این حال اینجانب حاضر به همکاری جهت جمع آوری و درج اطلاعات در سایتتان جهت جلوگیری از خاموشی همیشگی آن می باشم.

سيد محسن ميرشاهرضا: سلام به شما دوست عزيز سايتي که شما درست کرده ايد ارزش زيادي داره و من از اين که شما تصميم به تعطيل کردن آن گرفته ايد بسيار ناراحت شدم. نميدانم چرا اينکار را ميکنيد ولي ميدانم که اداره اين سايت براي شما کار بسيار مشکلي بوده است. در هر حال من همين اواخر اقدام به راه اندازي يک سايت کرده ام که شما را يکي از الگوهاي کاري خود قرار داده بودم ولي کار آخر شما را تاييد نميکنم و از شما ميخواهم که در آن تجديد نظر کنيد. تعداد سايتهاي فارسي آنقدر کم هست که در تصميمتان تجديد نظر کنيد. در هر براي شما صورت آرزوي موفقيت ميکنم. به ما سربزنيد http://www.bitup.com

سهیل رشیدی: تاریخ: 12/2/2002 2:32:11 PM فرستنده: مديريت IranASP.NET "...اميدوارم که در راه سختی که شروع کرده ايد موفق و پایدار باشيد. دقت کنيد که "پايدار باشيد". منظورم این است که راه اندازی چه آسان ولی افتاد مشکلها! البته بعيد می دانم که شما کار خوبی را که شروع کرده ايد را رها کنيد چون معلوم است که برای آن خيلی زحمت کشيده ايد و من شما را درک می کنم. " و من نیز شما را درک میکنم. برای شما و خانواده‌تان آرزوی سلامت و موفقیت دارم. سایت بهانه‌ای برای آشنایی بود، امیدوارم ارتباط خود را با ما قطع نکنید.

سعيد بيگدلي: ساسان عزيز: نميدونم دليل اين كار شما چيه و چرا اين تصميم رو گرفتي و .... ولي بايد به اين موضوع اعتراف كنم كه اين سايت و محيظ دوستانه و علمي اي كه شما به راه انداخته بودي تاثير زيادي رو من و امثال من داشت و به حق استفاده هاي زيادي از اين سايت برديم با آرزوي موفقيت براي شما (چه با iranaspو چه بدون iranasp)

فرهاد: سلام. فرهادم.برای اولین باره که اومدم اینجا و چند روزیه شروع کردم asp.net یاد میگیرم. سرچ کردم و اینجا رو پیدا کردم. اما نیومده ضدحاله رو خوردم. مثل اینکه ما دریا بریم یا نمیرسیم یا دریا خشک میشه. داری میری (رفتی) امیدوارم چیزی که از خودت تو این دنیا گذاشتی یادآور تو باشه و ازش چیزای زیادی یاد بگیرم و بگیریم. بنی آدم اعضای یکدیگرند که ... (چه ربطی داشت؟) آقا از آشنایی خوشحالم. حق!

مهرداد ابراهيمي: هرگز اولين باري كه ورود به IranAsp.NET رو تجربه كردم را فراموش نمي كنم، من كه از asp.net هيچي نميدونستم و فقط ميدونستم هر سايتي كه .aspx داره به NET. نوشته شده با خواندن مقالات اين سايت و رهنمودهاي شما و همكارانتان تونستم اطلاعات زيادي كسب كنم. مقالات مفيد و غير تجاري شما كه از طرز نگارش آن ميتوان فهميد وقت صرف جمله بندي آن شده است هيچ وقت از خاطر كساني كه اين مقالات را خوانده اند فراموش نمي شوند. مصاحبه هاي روحيه بخش شما با افراد حرفه اي داخل و خارج كشور هيچ وقت فراموش نخواهد شد . توضيح و مثال هاي سايت شما كه با دقت براي فارسي شدن آن وقت صرف شده بود فراموش نمي شود و بعد از تعطيلي اين سايت كه اميدوارم هيچ وقت اتفاق نيفته فارسي زبان به ندرت شاهد مقالات به درد بخور از بقيه سايت ها خواهند بود . ارداتمند شما مهرداد ابراهيمي http://www.dicfa.com

س.ز: سلام و خسته نباشید به خاطر تلاشهای شما در این چند سال . وقتی ماجرای خداحافظی را متوجه شدم خیلی خیلی ناراحت شدم . چند وقت پیش وقتی توی وبلاگتون راجع به یه مجله خارجی و سایتتون یه مطلب نوشته بودید من هم به عنوان یه ایرانی از صمیم قلب خوشحال شدم .امیدوارم این خداحافظی کوتاه باشه . من که تقریبا هر روز سایت شما را می دیدم و از این به بعد ...

بهنام یوسفی: باورم نمیشه که به همین راحتی تموم بشه. سال ها با این سایت زندگی کردیم، از مقالاتش استفاده کردیم و با اتفاقاتش ایده گرفتیم و خلاصه دلگرمی ما دات نت کار ها به این سایته. راستش حالم گرفته شده ...

مهدی کریمی مقام: ضمن عرض سلام و تحیات قبل از هر چیزی به پاس زحمات بی دریغ شما و دیگر همراهانتان، به جهت احیای این سایت علمی و منحصر به فرد تبریک گفته و آرزوی موفقیت روز افزون شما را از خداوند منان خواهانم. لازم می دانم ضمن تشکر به اطلاع آن جنابان عرضه بدارم چندی پیش موفق شدم با سایت شما و مقالات متنوع و مفید بر آگاهیم بیافزایم. با توجه به این دوران بلند عنایات شما به کاربران، این شوک نابهنگام بر آنم داشت در حد بضاعت دست کمک به طرف شما دراز کنم، حتمآ این تنها خواسته من نیست و هستند افرادی توانا تر و دانا تر که به کمک شما بشتابند. چنانچه با وجود خستگی و کمبود انگیزه اقدام به بستن سایت ننمودید، با کمال احترام و تواضع آمادگی خود را اعلام می دارم.

کيوان نيّری: Hi Just read: http://www.smartdevice.ir/Weblog/?AuthID=2&ID=302

شاهو طوفانی: سلام انگیزه ! دیریست که گشته ای فراموش ! دوست عزیز و استاد بزرگوار بنده انرژی حرکت خود را در دات نت مدیون شما هستم. و باز هم می گویم همیشه بیاد جمله معروفی که چهار سال پیش که در تماس تلفنی با شما داشتم هستم. هنر برنامه نویسی - هر وقت می خواهم سایتم را برپا کنم پیش خودم می گویم برای که !؟ برای چه !؟ در وضعیت کنونی که نااهلان - همانطور که مهدی در سایتشان گفته - فقط براساس روابط کاربدست گرفته اند همان به که سایت را تعطیل کنید ! چون من هم تجربه بی انگیزگی را داشته و دارم. زندگی متاسفانه اینجا همین است ضد حال خوردن محض !. به هر حال همیشه مدیون شما و کار بزرگتان هستم و بعنوان کسیکه سومین سایت دات نت ایرانی - براساس شواهد موجود! - را برپا کردم متشکر عزم راسختان هستم. مرامتان را عشقست و بس.

mohsen: salam man baraye edameye kare site iranasp.net hazeram in site ro az shoma kharidari konam. montazere pishnahade shoma hastam.

duke: حقته چه بهتر هرچی سایت مایکروسافتی کم شود چه بهتر انسانهایی که از تکنولوژی میکروسافت همراه با (خواسته های خصمانه اش ) حمایت کنند همان بهتر که از این تار هزار پود محو گردند انشا ا... خدا هدایتان کرده و از دشمنان مایکروسافت گردید هنگامی دوستم این مقاله را به من نشان داد از سر شوق از جایم بلند شدم و به هوا پریدم و خوشحالی این جملات را برای شما نوشتم امیدوارم از دست من ناراحت نشوید چون من از دشمنان قسم خورده مایکروسافت هستم

علي بابائي: خداحافظي از اين سايت برايم باورنكردني است، من فكر ميكنم مي توانيم با همكاري يكديگر اين كار بزرگ را ادامه دهيم، iranasp.net برايم يك الگو بود (و هست)، و تعطيلي آن باور نكردني است. بنده شخصا آمادگي اين رو دارم كه با شما همكاري كنم ، هرچند به اندازه شما و ديگران حرفه اي نيستم. به نظر من هم(مانند آقاي طاهري) يك forum ميتونه هدف بعدي باشه، به هر حال اميدوارم از تصميمتون منصرف بشيد.

حسین شرفی: ساسان عزیز ... بسته شدن این سایت ضربه بزرگی برای جامعه برنامه نویس ماست . سایتی که چند سال باهاش بزرگ شدیم و کلی از نوشته هاش یادگرفتیم و تو کارامون استفاده کردیم . می دونم که این روزمره گی خسته ات کرده ... اما خیلی ها هستند که تازه دارن وارد این دنیای بزرگ میشن و برای گفتن سلامی مانند hello world تو بهترین انتخابی ... هر کمکی بتونم میکنم تا پایدار باشید ... از قلمم تا کمک مالی و سرور و ... فقط نرو ... موفق باشی

محمدرضا طاهری: تعطیلی این سایت را دوست ندارم. تعطیلی وبلاگ گرو هی اش را دوست نداشتم . بسته شدن سرویس خبر آن را نمی پسندم . اما ساسان عزیز تو خود مختاری که بدون درخواست کمک از دیگران و به تنهائی تصمیم به این کارها بگیری. شاید من بی جهت iranasp.net را متعلق به همه علاقه مندان فارسی زبان دات نت می دانستم .شاید بی جهت همواره منتظر ظهور forum در آن بودم تا محلی مناسب برای تبادل نظر اعضاء و ارتقا دانش فنی من باشد. نمی دانم عدم درخواست تو بود و یا بی معرفتی من و امثال من که نتوانستیم به تو در ادامه راه کمک کنیم. اما این را چند وقتی بود که می دانستم پیش بردن سایتی مثل iranasp.net دیگر تک نفر مقدور نبود. خیلی چیزها از آن یاد گرفتم و مطالبش آرشیوی مناسب به زبان فارسی در اختیارم قرار داده است. امیدوارم که راهی عملی برای بقا وجود داشته باشد. اگر نه، که تو صاحب آن هستی و مختار به هر تصمیم گیری. من خود سابقه مدیریت یک ساله persianlearn.com را داشتم و مشکلات مجانی کار کردن و درخواست تولید محتوی مجانی از دیگران را می دانم اما سرمایه گذار آن سایت من تنها نبودم وگرنه به جای تعطیل کردن حتما راه حل دیگری می اندشیدم. اگر بتوانم نه فقط در دنیای مجازی، بلکه در مشکلات مادی آن هم در خدمتم. ارادتمند محمدرضا طاهری http://weblog.iranasp.net/taheri

فرشاد عجمی: آخه پسر خوب فكر مي كردم ASP.net كارا خيلي قوي تر از اين باشند . يعني چي من ASP و ASP.net ياد گرفتم با استفاده از مقاله هاي خوب سايت بود ، مگه چي شده مشكلي هست ما نبايد به يزاريم اين سايت بخوابه ، من آماده ام اطلاعاتي كمم را به صورت آموزش هاي كاربردي ASP.net را به صورت مقاله بفرستم و همينطور خيلي از دوستان ديگه web : www.tarhno.com اين سايت من پيشنهاد دارم امكانات سايت بيشترش كنيد

جواد مرسلی: سلام. خواستم از شما به خاطر تمام زحماتتان تشکر کنم.راستش من تمام پیشرفت علمی و کاری خود را از شما دارم و به همین خاطر سپاس گذارم.ادرس ایمیل بنده در نامه ذکر شده.اگر هرگونه کار و خدمت از بنده بر میامد در خدمت گذاری حاضرم.موفق باشید.خدانگهدار

گل پسر: تو یه خری... یه احمق... با این مقالت حالم رو بد کردی... ای کاش می موندی... اما حالا که داری می ری... خوب باشی :)

محسن: با عرض سلام و خسته نباشید برای شما دوست عزیز و بقیه دوستان و همکاران شما. باور کنید در حالی که در بدترین لحظه زندگیم بودم شنیدن خبر خدا حافظی شما نیز بار سنگینی بود. به هر حال از شما بینهایت سپاسگذارم که من به عنوان یکی از خوانندگان این سایت بسیار خوب استفاده بینهایتی بردم هر جا که هستین و به هر کاری که مشغول هستین برای شما آرزوی پیروزی و موفقیت دارم یا حق

همه مقالات کليات ASP.NET را ببينيد.
جستجو: بگرد!
جستجوی پيشرفته
نام کاربری |
کلمه عبور |


IranASP.NET - خبرها

خبرها

جهت ارسال خبر به صفحه ويژه اعضا - ارسال خبر مراجعه نمائيد.

101 مثال برای Visual Studio 2005 جديد!
توسط محمدرضا طاهري
۱۳۸۴ پنجشنبه ۱۰ شهريور - شامل مثال هائی به زبان سی شارپ و VB و قابلیت های جدید آن بيشتر

الگوهای طراحی نرم افزار استفاده شده در دات نت جديد!
توسط محمدرضا طاهري
۱۳۸۴ پنجشنبه ۱۰ شهريور - اگر می خواهید با الگوهای طراحی نرم افزار (عمومی / مایکروسافت ) که در طراحی کلاسهای موجود در framework دات نت استفاده شده است آشنا شوید حتما این مقاله را بخوانید. بيشتر

چگونه يک Host مناسب برای سايت ASP.NET خود انتخاب کنيم؟ جديد!
توسط مديريت سايت
۱۳۸۴ پنجشنبه ۲۳ تير - اين مقاله Host خاصی را معرفی نمی‌کند بلکه به معيار مورد نظر جهت انتخاب يک Host مناسب برای سايت ASP.NET شما می‌پردازد و نکات امنيتی و نحوه ارزيابی آنها را بيان می‌دارد. بيشتر

تبدیل تاریخهای میلادی، شمسی و قمری به یکدیگر با استفاده از Persia API جديد!
توسط Shahabfar.com Iranian .NET Community
۱۳۸۴ يکشنبه ۱۹ تير - با توجه به در اختیار نبودن اطلاعاتی در مورد تقویم هجری شمسی (جلالی) در کتابخانه NET. برنامه نویسان ایرانی همواره خود به دنبال راه حلهایی جهت گنجاندن قابلیت استفاده از تقویم شمسی در برنامه های کاربردی... بيشتر

استيو بالمر کشتی Visual Studio 2005 را در تاريخ 7 نوامبر در سان فرانسيسکو به آب خواهد انداخت جديد!
توسط مديريت سايت
۱۳۸۴ چهارشنبه ۱۵ تير - نسخ نهايی محصولات VS05 و SQL Server 2005 و BizTalk 2006 در تاريخ 7 نوامبر 2005 در شهر سان فرانسيسکو طی مراسم افتتاحيه کنفرانس VSLive توسط استيو بالمر مدير اجرايی مايکروسافت افتتاح خواهند شد. بيشتر

چرا من از DataSet در برنامه‌های ASP.NET استفاده نمی‌کنم؟ جديد!
توسط مديريت سايت
۱۳۸۴ سه شنبه ۷ تير - Scott Mitchell در اين مقاله ابتدا DataSet و DataReader را با هم مقايسه کرده است و مزايا و معايب هر يک را آورده است. بيشتر

حبابی کردن Eventها در کنترل‌ها جديد!
توسط مديريت سايت
۱۳۸۴ سه شنبه ۷ تير - Scott Mitchell در اين مقاله به نحوه چگونگی پاسخ دهی به رويدادهای درون يک کنترل پائينی در يک کنترل بالايی که اصطلاحاً حبابی کردن نام دارد می‌پردازد. بيشتر

سمينار "آشنايي با تكنولوژي پورتال Microsoft SharePoint" جديد!
توسط
۱۳۸۴ يکشنبه ۲۹ خرداد - شركت نرم‌افزاري پريان با همكاري شركت گستره نگار اقدام به برگزاري اولين سمينار آشنايي با SharePoint در ايران با عنوان: "آشنايي با تكنولوژي پورتال مايكروسافت" نموده است. اين سمينار در تاريخ 28/04/1384... بيشتر

کشتی Visual Studio 2005 در تاريخ 7 نوامبر به آب انداخته خواهد شد! جديد!
توسط مديريت سايت
۱۳۸۴ چهارشنبه ۱۸ خرداد - مايکروسافت اعلام کرد که مجموعه‌های Visual Studio 2005 و SQL Server 2005 و BizTalk Server 2006 رسماً در تاريخ 7 نوامبر 2005 ارائه خواهند شد. بيشتر

مدل کد در ASP.NET 2.0 جديد!
توسط مديريت سايت
۱۳۸۴ جمعه ۱۳ خرداد - اين مقاله به بررسی انواع مدلهای کد در ASP.NET 2.0 پرداخته و سعی می‌کند مزايا و معايب آنها را بيان کند. بيشتر

« بعدی ۵ ۴ ۳ ۲ ۱ قبلی »

جستجو: بگرد!
جستجوی پيشرفته
نام کاربری |
کلمه عبور |


IranASP.NET - مدل کد در ASP.NET 2.0

مدل کد در ASP.NET 2.0

توسط مديريت سايت
تاريخ انتشار: ۱۳۸۴ جمعه ۱۳ خرداد
برای وبلاگ برای وبلاگ

آگهی

اين مقاله به بررسی انواع مدلهای کد در ASP.NET 2.0 پرداخته و سعی می‌کند مزايا و معايب آنها را بيان کند.

اصل مطلب

» همه خبرها
جستجو: بگرد!
جستجوی پيشرفته
نام کاربری |
کلمه عبور |


IranASP.NET - کشتی Visual Studio 2005 در تاريخ 7 نوامبر به آب انداخته خواهد شد!

کشتی Visual Studio 2005 در تاريخ 7 نوامبر به آب انداخته خواهد شد!

توسط مديريت سايت
تاريخ انتشار: ۱۳۸۴ چهارشنبه ۱۸ خرداد
برای وبلاگ برای وبلاگ

آگهی

مايکروسافت اعلام کرد که مجموعه‌های Visual Studio 2005 و SQL Server 2005 و BizTalk Server 2006 رسماً در تاريخ 7 نوامبر 2005 ارائه خواهند شد.

اصل مطلب

» همه خبرها
جستجو: بگرد!
جستجوی پيشرفته
نام کاربری |
کلمه عبور |


IranASP.NET - سمينار "آشنايي با تكنولوژي پورتال Microsoft SharePoint"

سمينار "آشنايي با تكنولوژي پورتال Microsoft SharePoint"

توسط
تاريخ انتشار: ۱۳۸۴ يکشنبه ۲۹ خرداد
برای وبلاگ برای وبلاگ

آگهی

شركت نرم‌افزاري پريان با همكاري شركت گستره نگار اقدام به برگزاري اولين سمينار آشنايي با SharePoint در ايران با عنوان: "آشنايي با تكنولوژي پورتال مايكروسافت" نموده است. اين سمينار در تاريخ 28/04/1384 برگزار مي‌شود.

اصل مطلب

» همه خبرها
جستجو: بگرد!
جستجوی پيشرفته
نام کاربری |
کلمه عبور |


IranASP.NET - چرا من از DataSet در برنامه‌های ASP.NET استفاده نمی‌کنم؟

چرا من از DataSet در برنامه‌های ASP.NET استفاده نمی‌کنم؟

توسط مديريت سايت
تاريخ انتشار: ۱۳۸۴ سه شنبه ۷ تير
برای وبلاگ برای وبلاگ

آگهی

Scott Mitchell در اين مقاله ابتدا DataSet و DataReader را با هم مقايسه کرده است و مزايا و معايب هر يک را آورده است.

اصل مطلب

» همه خبرها
جستجو: بگرد!
جستجوی پيشرفته
نام کاربری |
کلمه عبور |


IranASP.NET - حبابی کردن Eventها در کنترل‌ها

حبابی کردن Eventها در کنترل‌ها

توسط مديريت سايت
تاريخ انتشار: ۱۳۸۴ سه شنبه ۷ تير
برای وبلاگ برای وبلاگ

آگهی

Scott Mitchell در اين مقاله به نحوه چگونگی پاسخ دهی به رويدادهای درون يک کنترل پائينی در يک کنترل بالايی که اصطلاحاً حبابی کردن نام دارد می‌پردازد.

اصل مطلب

» همه خبرها
جستجو: بگرد!
جستجوی پيشرفته
نام کاربری |
کلمه عبور |


IranASP.NET - استيو بالمر کشتی Visual Studio 2005 را در تاريخ 7 نوامبر در سان فرانسيسکو به آب خواهد انداخت

استيو بالمر کشتی Visual Studio 2005 را در تاريخ 7 نوامبر در سان فرانسيسکو به آب خواهد انداخت

توسط مديريت سايت
تاريخ انتشار: ۱۳۸۴ چهارشنبه ۱۵ تير
برای وبلاگ برای وبلاگ

آگهی

نسخ نهايی محصولات VS05 و SQL Server 2005 و BizTalk 2006 در تاريخ 7 نوامبر 2005 در شهر سان فرانسيسکو طی مراسم افتتاحيه کنفرانس VSLive توسط استيو بالمر مدير اجرايی مايکروسافت افتتاح خواهند شد.

اصل مطلب

» همه خبرها
جستجو: بگرد!
جستجوی پيشرفته
نام کاربری |
کلمه عبور |


IranASP.NET - تبدیل تاریخهای میلادی، شمسی و قمری به یکدیگر با استفاده از Persia API

تبدیل تاریخهای میلادی، شمسی و قمری به یکدیگر با استفاده از Persia API

توسط Shahabfar.com Iranian .NET Community
تاريخ انتشار: ۱۳۸۴ يکشنبه ۱۹ تير
برای وبلاگ برای وبلاگ

آگهی

با توجه به در اختیار نبودن اطلاعاتی در مورد تقویم هجری شمسی (جلالی) در کتابخانه NET. برنامه نویسان ایرانی همواره خود به دنبال راه حلهایی جهت گنجاندن قابلیت استفاده از تقویم شمسی در برنامه های کاربردی خود می باشند. Persia API یک کتابخانه با استفاده رایگان می باشد که برنامه نویسان به کمک آن می توانند به راحتی و تنها با یک یا دو خط کدنویسی تاریخهای هجری شمسی، هجری قمری و میلادی را در برنامه های مبتنی بر NET. به یکدیگر تبدیل نمایند.

اصل مطلب

» همه خبرها
جستجو: بگرد!
جستجوی پيشرفته
نام کاربری |
کلمه عبور |


IranASP.NET - چگونه يک Host مناسب برای سايت ASP.NET خود انتخاب کنيم؟

چگونه يک Host مناسب برای سايت ASP.NET خود انتخاب کنيم؟

توسط مديريت سايت
تاريخ انتشار: ۱۳۸۴ پنجشنبه ۲۳ تير
برای وبلاگ برای وبلاگ

آگهی

اين مقاله Host خاصی را معرفی نمی‌کند بلکه به معيار مورد نظر جهت انتخاب يک Host مناسب برای سايت ASP.NET شما می‌پردازد و نکات امنيتی و نحوه ارزيابی آنها را بيان می‌دارد.

اصل مطلب

» همه خبرها
جستجو: بگرد!
جستجوی پيشرفته
نام کاربری |
کلمه عبور |


IranASP.NET - الگوهای طراحی نرم افزار استفاده شده در دات نت

الگوهای طراحی نرم افزار استفاده شده در دات نت

توسط محمدرضا طاهري
تاريخ انتشار: ۱۳۸۴ پنجشنبه ۱۰ شهريور
برای وبلاگ برای وبلاگ

آگهی

اگر می خواهید با الگوهای طراحی نرم افزار (عمومی / مایکروسافت ) که در طراحی کلاسهای موجود در framework دات نت استفاده شده است آشنا شوید حتما این مقاله را بخوانید.

اصل مطلب

» همه خبرها
جستجو: بگرد!
جستجوی پيشرفته
نام کاربری |
کلمه عبور |


IranASP.NET - 101 مثال برای Visual Studio 2005

101 مثال برای Visual Studio 2005

توسط محمدرضا طاهري
تاريخ انتشار: ۱۳۸۴ پنجشنبه ۱۰ شهريور
برای وبلاگ برای وبلاگ

آگهی

شامل مثال هائی به زبان سی شارپ و VB و قابلیت های جدید آن

اصل مطلب

» همه خبرها
جستجو: بگرد!
جستجوی پيشرفته
نام کاربری |
کلمه عبور |


IranASP.NET - درباره

درباره

IranASP.NET وب سايتی جهت معرفی و ارائه مطالب به زبان فارسی در مورد ASP.NET است. ASP.NET يک فناوری پيشرو و ارائه شده از سوی شرکت Microsoft در زمينه ساخت سايت‎های وب و برنامه‎های تحت وب می باشد.
IranASP.NET فعاليت خود را از آبان ماه ۱۳۸۰ (October, 2001) آغاز نمود و از همان روزهای آغازين به عنوان "انجمن کاربران ASP.NET ايران" توسط مايکروسافت در سايت رسمی ASP.NET معرفی گرديد. اما ما IranASP.NET را سايتی برای همه فارسی زبانان در سرتاسر دنيا که علاقمند به فراگيری و برنامه نويسی ASP.NET می‎باشند، می‎دانيم.
مطالب آموزشی اين سايت بطور عمده در قالب مقالات و خودآموزها ارائه می‎گردد و برخی از مقالات دارای کد برنامه مربوطه نيز می‎باشند.
خبرها به شما کمک می‎کنند تا همواره از آخرين اطلاعات و رويدادهای دنيای ASP.NET مطلع باشيد.
با عضويت رايگان در سايت IranASP.NET شما از امکانات ويژه اعضای سايت برخوردار می‎شويد. اين امکانات در حال افزايش می‎باشند و برخی از آنها در حال حاضر عبارتند از امکان انتشار مقاله و خبر توسط شما و بنام شما در سايت IranASP.NET و اشتراک رايگان ماهنامه سايت.
IranASP.NET سايتی پويا و بالنده است که همواره در حال رشد و بهبود خدمات خود می‎باشد و اين بالندگی ميسر نخواهد شد مگر با همراهی و ياری شما. بنابراين در بيان نقطه نظرات خود به ما درنگ ننمائيد.
جستجو: بگرد!
جستجوی پيشرفته
نام کاربری |
کلمه عبور |


IranASP.NET - آگهی در سايت

آگهی در سايت

تبليغات خود را به اولين و پربيننده ترين سايت آموزشی ايرانی و فارسی بسپاريد:

  • يک ماه آگهی فقط ۲۰ هزار تومان

سايت IranASP.NET خدمات آگهی خود را بصورت زير ارائه می نمايد:

۱- ابتدا نوع آگهی (اندازه و محل) مورد نظر خود را از ميان سه نوع آگهی A و B و C موجود در همين صفحه انتخاب نمائيد.

۲- تصوير آگهی يا بنر مورد نظر خود بهمراه URL مربوطه را به نشانی Site [at] IranASP.net برای ما ارسال نمائيد.

۳- سپس اطلاعات مربوط به نحوه پرداخت تعرفه از طريق حساب بانکی بوسيله ايميل برای شما ارسال گردد.

۴- پس از اطمينان از واريز تعرفه مربوطه، آگهی شما به مدت يک ماه در سايت IranASP.NET قرار می گيرد.

  • کليه ارتباطات از طريق ايميل خواهد بود و نيازی به مراجعه حضوری شما نمی باشد.
  • محدوديتی در دفعات تعويض تصوير آگهی (بنر) شما وجود ندارد.

جهت کسب اطلاعات بيشتر يا سفارش آگهی لطفا با آدرس زير تماس بگيريد:

Site [at] IranASP.net

نام آگهی | مشخصات آگهی
A | محل: بالای کليه صفحات قيمت: ۲۰ هزار تومان برای يک ماه
B | محل: کليه صفحات مقالات و خبرها قيمت: ۲۰ هزار تومان برای يک ماه
C | محل: سمت چپ کليه صفحات قيمت: ۲۰ هزار تومان برای يک ماه
جستجو: بگرد!
جستجوی پيشرفته
نام کاربری |
کلمه عبور |


IranASP.NET - ارتباط با ما

ارتباط با ما

لطفا جهت ارتباط با ما از فرم زير استفاده نمائيد يا با آدرس Site [at] IranASP.net با ما تماس بگيريد.

توجه:
سايت IranASP.NET بدليل دريافت حجم بالای نامه ها، متاسفانه قادر به پاسخگويی به سوالات و مشکلات برنامه نويسی شما نمی باشد. لطفا تنها در مورد مسائل مربوط به سايت برای ما نامه بفرستيد. با تشکر

موضوع :
نام شما :
آدرس E-mail : * *
جستجو: بگرد!
جستجوی پيشرفته
نام کاربری |
کلمه عبور |


IranASP.NET - پيوند به ما

پيوند به ما

جهت حمايت از IranASP.NET می توانيد يکی از تصاوير زير را در سايت خود قرار داده و پيوند (link) آن را مطابق http://www.IranASP.net قرار دهيد.

100x30
100x30
100x50
100x50
468x60

جستجو: بگرد!
جستجوی پيشرفته
نام کاربری |
کلمه عبور |


IranASP.NET - شرايط استفاده از سايت

شرايط استفاده از سايت

لطفا شرايط استفاده از اين سايت، که در زير آمده است، را قبل از ورود و استفاده از سايت به دقت بخوانيد چرا که با استفاده از اين سايت ما فرض می کنيم که شما شرايط زير را پذيرفته و با همه موارد زير کاملا موافق هستيد.

در صورت وجود هرگونه ابهام لطفا با مديريت سايت تماس بگيريد.

۱- استفاده از محتوای اين سايت جهت آموزش و فراگيری مطالب کاملا رايگان است. اما هرگونه سوءاستفاده به هر شکلی يا انتشار مجدد مطالب بدون کسب اجازه از مديريت سايت و بدون ذکر منبع اکيدا ممنوع است.

۲- هرگونه استفاده تجاری از مطالب سايت يا نشر مجدد مطالب در نشريات بدون کسب اجازه از مديريت سايت اکيدا ممنوع است.

۳- هيچ چيز در اين سايت تضمين نمی شود و همه مطالب تحت عنوان "همانطور که گفته می شود" يا "AS IS" می باشد بطوريکه مسؤوليت استفاده از کليه نمونه برنامه ها و ساير موارد بعهده استفاده کننده است.

۴- کليه پيوندها به ديگر سايت ها در اين سايت صرفاً جهت اطلاع است و اين سايت کنترلی بر محتوای آنها ندارد لذا مسؤوليت محتوی و استفاده از آنها را بعهده نمی گيرد.

۵- کليه اطلاعات، نظرات، پيشنهادات، سوؤالات، انتقادات و هر آنچه که از جانب شما به هر طريقی به ما ارسال شود محرمانه تلقی نخواهد شد و مديريت سايت در نشر مجدد، استفاده و بکارگيری و يا حذف آنها کاملا آزاد است.
جستجو: بگرد!
جستجوی پيشرفته
نام کاربری |
کلمه عبور |


PARIANSOFT :: SharePoint Technologies Seminar :: 28 Tir 1384

آخرين اخبار

ارايه مجموعه امكانات فارسي براي Windows SharePoint Services بيشتر بدانيد

آخرين نسخه اصلاحي براي نرم‌افزار پرنيان3 (MSP2002) بيشتر بدانيد

تخفيف ويژه نوروزي محصولات نرم‌افزاري گروه كنترل پروژه.

بيشتر بدانيد

به دنبال ارائه نرم‌افزار پيكسل، شما مي‌توانيد پروژه‌هايتان را در Microsoft Excel دنبال نماييد.

بيشتر بدانيد

پرنيان4 (تقويم شمسي و امكانات فارسي براي Microsoft Project 2003) را از دپارتمان فروش يا از نمايندگي‌هاي اين شركت تهيه نماييد.

بيشتر بدانيد

سمينار "آشنايي با تكنولوژي پورتال مايكروسافت" 28 تير‌ماه 1384

شركت نرم‌افزاري پريان با همكاري شركت گستره نگار اقدام به برگزاري اولين سمينار آشنايي با SharePoint در ايران با عنوان: "آشنايي با تكنولوژي پورتال مايكروسافت" نموده است.
اين سمينار در تاريخ 28/04/1384 برگزار مي‌شود. از آنجاييكه محدوديت‌هايي براي تعداد شركت كنندگان وجود دارد، خواهشمند است در صورت تمايل به شركت در اين سمينار، لطفا معرفي نامه خود بر روي سربرگ شركت را به شماره فكس يا آدرس پست الكترونيكي زير ارسال نماييد.

محورهاي اصلي اين سمينار عبارتند از:
1. معرفي و آشنايي كلي با تكنولوژي Microsoft Windows SharePoint Services
در اين مبحث سعي خواهد شد كليات اين تكنولوژي و محصولات وابسته خصوصا سايت‌هايي كه توسط Windows SharePoint Services مورد بررسي قرار گرفته و امكانات و ويژگي‌هاي آنها تا حد امكان تشريح شوند.

2. معرفي امكانات فارسي براي Windows SharePoint Services
با توجه به پشتيباني تكنولوژي‌هاي SharePoint از زبان‌هاي مختلف، اين شركت اقدام به تهيه امكانات زبان فارسي مطابق با استانداردها و امكانات نرم‌افزار اصلي نموده است كه در اين بخش به گوشه‌هايي از اين ويژگي‌ها اشاره خواهد شد.

شماره فكس: 8731191
شماره تلفن تماس: 8731192 و 8736313

آدرس پست الكترونيكي: sharepoint.seminar@gnco.ir

برنامه و زمانبندي

سمينار "آشنايي با تكنولوژي پورتال مايكروسافت" در تاريخ 28/04/1384 و در محل سالن آمفي تئاتر هتل سيمرغ تهران از ساعت 15 الي 18 برگزار خواهد شد. رئوس مطالبي كه در اين سمينار ارائه خواهد شد عبارت است از:

معرفي تكنولوژي SharePoint
 معرفي Windows SharePoint Services
 معرفي SharePoint Portal Server 2003
 بررسي برخي Case Study-ها
مسائل Localization و معرفي امكانات فارسي در محيط SharePoint

ساعت | موضوع | سخنران
15:00 الي 15:30 | مقدمه‌اي بر تكنولوژي پورتال مايكروسافت | آقاي مهندس بابك محمودي (شركت گستره‌نگار)
15:30 الي 16:00 | امكانات SharePoint در سيستم‌هاي اتوماسيون اداري | آقاي مهندس مجيد فروشان (شركت البرز رايانيكا)
16:00 الي 16:30 | بررسي محصولات و امكانات Sharepoint | آقاي مهندس ادوين هاكوپيان (شركت گستره‌نگار)
16:30 الي 16:50 | _______________پذيرايي_______________ |
16:50 الي 17:20 | مديريت گردش‌كار در SharePoint | آقاي مهندس رضا صاحب‌زماني (شركت رميس)
17:20 الي 17:40 | نقش SharePoint در مديريت دانش سازمان | آقاي مهندس امير مهراني (شركت عصر دانش افزار)
17:40 الي 18:00 | چگونه توسط SharePoint يك سايت مالي ساختيم | آقاي مهندس بابك محمودي (شركت گستره‌نگار)
18:00 الي 18:45 | _______________بحث آزاد________________ |

تغييرات برنامه و زمانبندي اين سمينار را متعاقبا از همين صفحه دنبال نماييد.

خانه محصولات پروژه‌ها اخبار مقالات باراندازي سؤالات درباره ما

آدرس: تهران، خ شهيد بهشتي بعد از پل مدرس، شماره 279
تلفن: 8731191 8 (021) فكس: 8731192 8 (021)

#279, Shahid Beheshti Ave.

15146 Tehran/Iran

Tel: +98(21) 8 8731191

Copyright ©2005 pariansoft.com


Persia API the .NET Date Converter

درباره سایت
Shahabfar.com Iranian .NET Community |
۱۳۸۴ شنبه ۱۶ مهر | صفحه اول تازه ها مقالات کتابها مجلات فصلهای نمونه پوسترها ارسال مطلب معرفی سایت به دیگران

.NET

اصول وب سرویسها

مقدمه ای بر #C

سوالات متداول
عضویت در سایت
آدرس ايميل خود را وارد کنيد

با عضويت در سايت جديدترين مطالب در زمينه NET. در قالب خبرنامه به آدرس ايميل شما ارسال خواهد شد

فرمت آدرس ایمیل وارد شده صحیح نمی باشد

تبدیل تاریخهای میلادی، شمسی و قمری به یکدیگر

با توجه به در اختیار نبودن اطلاعاتی در مورد تقویم هجری شمسی (جلالی) در کتابخانه NET. برنامه نویسان ایرانی همواره خود به دنبال راه حلهایی جهت گنجاندن قابلیت استفاده از تقویم شمسی در برنامه های کاربردی خود می باشند.
Persia API یک کتابخانه با استفاده رایگان می باشد که برنامه نویسان به کمک آن می توانند به راحتی و تنها با یک یا دو خط کدنویسی تاریخهای هجری شمسی، هجری قمری و میلادی را در برنامه های مبتنی بر NET. به یکدیگر تبدیل نمایند.
Persia API از جمله کتابخانه هایی است که امکان استفاده از تقویم هجری شمسی شامل تبدیل آن به تاریخ های میلادی و هجری قمری و بالعکس را دارا می باشد. با آنکه کتابخانه NET. اطلاعات مربوط به تقویم هجری قمری ( تقویم اسلامی) را در خود گنجانده است، ولی با همه اینها کتابخانه Persia قابلیت تبدیل تاریخ میلادی به هجری قمری و با لعکس را به روش ساده تری مهیا نموده است.

مقاله ذیل توضیحات بیشتری در مورد این کتابخانه و نحوه استفاده از آن را در اختیار علاقه مندان گذاشته است.

تبدیل تاریخها با استفاده از Persia API

تولید اعداد فارسی

با وجود آنکه برای تولید اعداد فارسی آنهم بطور پویا در برنامه های مبتنی بر وب راه حلهای مختلفی وجود دارد ولی باز هم مشاهده می شود که در اکثر وب سایتهای فارسی همچنان از اعداد لاتین در کنار خطوط فارسی استفاده می شود. کتابخانه Persia برای آن دسته از برنامه نویسانی که خود به دنبال حل این مسئله نیستند راه حل ساده ای را پیش رو گذاشته است.

دریافت Persia API

Persia API یک کتابخانه با استفاده رایگان می باشد و استفاده از آن در برنامه های مختلف شامل هیچگونه محدودیتی نبوده و کاملا" آزاد می باشد. جهت دریافت (download) آن کافیست آدرس ایمیل خود را در ذیل وارد نمایید. فایل دریافت شده یک فایل zip شده می باشد که شامل فایل DLL مربوط به کتابخانه مورد نظر و دو مثال به همراه سورس کد جهت بیان نحوه بکارگیری Persia API در برنامه های کاربردی می باشد. این دو مثال در قالب برنامه های WinForm و WebForm می باشند.

لطفا" آدرس ایمیل خود را وارد کنیدآدرس ایمیل وارد شده صحیح نمی باشد ایمیل خود را وارد کنید
هرگونه سؤال، نظر و پیشنهاد خود را در مورد Persia API برای ما ارسال کنید.
نام:
پست الکترونیک:
Copyright ©2002-2005 | | Shahabfar.com | | info@shahabfar.com
All rights reserved for Shahabfar.com |  |


The page cannot be found
The page you are looking for might have been removed, had its name changed, or is temporarily unavailable.

Please try the following:

  • If you typed the page address in the Address bar, make sure that it is spelled correctly.
  • Open the home page, and then look for links to the information you want.
  • Click the Back button to try another link.

HTTP 404 - File not found
Internet Information Services

Technical Information (for support personnel)

  • More information:
    Microsoft Support