Information Systems

Boosting Your Web App's Interactivity with Asp.Net Core 7 SignalR

2023-03-19T02:12:00.005-07:00

Boosting Your Web App's Interactivity with Asp.Net Core 7 SignalR

‍

In today's digital age, user engagement is more important than ever. As businesses strive to create a seamless and interactive experience for their customers, web applications have become a crucial tool. However, simply having a web app is not enough. To truly stand out in a crowded online marketplace, it's essential to boost its interactivity. That's where Asp.Net Core 7 SignalR comes in. By integrating this powerful framework into your web app, you can take your user engagement to the next level. From real-time updates and notifications to chat functionality and more, SignalR makes it easy to create an immersive user experience that keeps your visitors coming back for more. In this article, we'll explore the benefits of Asp.Net Core 7 SignalR and how you can use it to boost your web app's interactivity. So, whether you're a seasoned developer or just starting out, let's dive in and discover how SignalR can take your web app to the next level.

Benefits of using SignalR for web app interactivity

SignalR is a real-time communication framework that enables bi-directional communication between client and server. Its key feature is that it allows you to push data from the server to the client as soon as it's available, without the need for the client to request it. This opens up a world of possibilities for web app interactivity. Here are just a few of the benefits of using SignalR:

Real-time updates and notifications

One of the most powerful features of SignalR is the ability to push real-time updates to the client. This means that you can instantly update the UI in response to changes on the server, without the need for the user to refresh the page. This is perfect for applications that require real-time updates, such as stock tickers, sports scores, or chat apps.

Chat functionality

SignalR makes it easy to implement chat functionality in your web app. With SignalR, you can create a real-time chat application that allows users to communicate with each other instantly. This is perfect for social networking sites or any application that requires real-time communication between users.

Improved user engagement

By providing real-time updates and notifications, SignalR can significantly improve user engagement. Users are more likely to stay on your site if they feel that they are getting the latest information in real-time. This can lead to increased user satisfaction, repeat visits, and ultimately, increased revenue.

How SignalR works

At its core, SignalR is a .NET library that provides server-side and client-side APIs for real-time communication. The server-side API is responsible for handling connections, managing groups of clients, and pushing messages to the clients. The client-side API is responsible for connecting to the server, receiving messages, and updating the UI in response to those messages.

SignalR uses several transport protocols to establish a connection between the client and server. These include WebSockets, Server-Sent Events (SSE), Long Polling, and Forever Frame. The transport protocol used depends on the capabilities of the client and server, and the network conditions.

Setting up SignalR in your Asp.Net Core 7 project

Setting up SignalR in your Asp.Net Core 7 project is simple. Here's how to do it:

Install the SignalR package using NuGet.
Add the SignalR middleware to your app's request pipeline.
Create a SignalR hub by inheriting from the Hub class.
Add methods to the hub that will be called by clients.
Call client methods from the server.

Implementing real-time communication with SignalR

Implementing real-time communication with SignalR is straightforward. Here's an example of how to send a message from the server to the client:

Create a hub method that sends a message to clients.

csharp public async Task SendMessage(string user, string message) { await Clients.All.SendAsync("ReceiveMessage", user, message); } 2. Call the hub method from the client.

javascript connection.on("ReceiveMessage", function (user, message) { // Update the UI with the message });

Call the server method from the client.

javascript connection.invoke("SendMessage", user, message);

SignalR hub and client-side code

A SignalR hub is a class that acts as a high-level pipeline between the server and the client. The hub contains methods that can be called by clients and methods that can be called by the server. When a client connects to the hub, SignalR automatically generates a JavaScript proxy that can be used to call the hub's server-side methods.

To call a server-side method from the client, you can use the invoke method on the connection object. To call a client-side method from the server, you can use the Clients property on the hub object.

Broadcasting messages with SignalR

SignalR makes it easy to broadcast messages to groups of clients. Here's an example of how to send a message to a specific group of clients:

Create a group.

csharp public async Task AddToGroup(string groupName) { await Groups.AddToGroupAsync(Context.ConnectionId, groupName); }

Send a message to the group.

csharp public async Task SendMessageToGroup(string groupName, string message) { await Clients.Group(groupName).SendAsync("ReceiveMessage", message); }

Call the group method from the client.

```javascript connection.invoke("AddToGroup", groupName).catch(function (err) { return console.error(err.toString()); });

connection.on("ReceiveMessage", function (message) { // Update the UI with the message }); ```

Scaling your SignalR application

As your SignalR application grows, you may need to scale it to handle more clients and messages. Here are a few tips for scaling your SignalR application:

Use a load balancer to distribute traffic across multiple servers.
Use a distributed cache to store connection information and messages.
Use a message broker such as RabbitMQ or Azure Service Bus to handle large volumes of messages.

Debugging and troubleshooting SignalR issues

Debugging and troubleshooting SignalR issues can be challenging. Here are a few tips for troubleshooting common issues:

Use the SignalR diagnostics page to view detailed information about connections, messages, and errors.
Use browser developer tools to inspect network traffic and debug client-side code.
Use logging to track server-side events and errors.

Best practices for SignalR development

Here are a few best practices for SignalR development:

Keep messages small to reduce network traffic.
Use authentication and authorization to secure your SignalR application.
Use a message schema to ensure compatibility between different versions of your application.

Conclusion

In conclusion, Asp.Net Core 7 SignalR is a powerful framework for boosting your web app's interactivity. By providing real-time updates and notifications, chat functionality, and improved user engagement, SignalR can help you create a more immersive user experience that keeps visitors coming back for more. With easy setup, straightforward implementation, and the ability to scale as your app grows, SignalR is a must-have tool for any web app developer. By following best practices and troubleshooting common issues, you can ensure that your SignalR application is secure, efficient, and provides the best possible user experience. So why wait? Start exploring the power of SignalR today and take your web app to the next level!

Simplify Your Data Synchronization Process with Dapper and Bulk Insert in ASP.NET

2023-02-19T04:03:00.002-08:00

Introduction:

Data synchronization is the process of maintaining consistent and accurate data across multiple systems or devices. In modern software systems, data synchronization has become increasingly important due to the proliferation of data and the need to ensure that information is accurate and up-to-date. In today's world, businesses and organizations rely heavily on data to make informed decisions, and any inaccuracies or inconsistencies in that data can lead to serious consequences.

Code Example

Importance of Data Synchronization:

Data synchronization is critical in modern software systems for several reasons:

Data Consistency: In any system where data is used across multiple devices or platforms, ensuring data consistency is essential. Data synchronization ensures that any changes made to the data in one system are automatically reflected in all other systems, ensuring that all users have access to the most up-to-date and accurate information.
Improved Productivity: When data is synchronized across all systems, it reduces the need for manual data entry, which can be time-consuming and prone to errors. This can improve overall productivity by freeing up time for employees to focus on other tasks.
Enhanced Collaboration: Data synchronization allows for improved collaboration between team members, regardless of their location. With synchronized data, team members can work together in real-time, sharing information and making decisions based on the most up-to-date information available.
Disaster Recovery: In the event of a system failure or data loss, data synchronization can be used to quickly restore data from a backup, reducing the impact of any downtime and minimizing the risk of data loss.

In conclusion, data synchronization is a crucial component of modern software systems. It ensures data consistency, improves productivity, enhances collaboration, and enables efficient disaster recovery. As businesses and organizations continue to rely on data to make informed decisions, data synchronization will become increasingly important in ensuring that that data is accurate, up-to-date, and readily available.

Data synchronization is the process of ensuring that data is consistent and up-to-date across multiple systems or databases. In many software applications, data is stored in multiple databases, and it is essential to ensure that changes made to the data in one database are propagated to all the other databases in a timely and accurate manner. This is where the dataSync service comes in handy.

The dataSync service uses a combination of SQL queries and bulk copy operations to synchronize data between the two databases. It first retrieves the data from the source database using a SELECT statement and applies any filters and sorting rules specified by the user. The service then compares the data with the destination database to identify any changes or additions. It filters out any data that already exists in the destination database and applies any updates or additions to the destination database using bulk copy operations.

Overall, the dataSync service offers a reliable and efficient way to synchronize data between two databases in limited scenarios. It helps to ensure that data is consistent and up-to-date across multiple systems, which is essential for modern software applications.

Code Example
SyncTable method:

The method is declared with several input parameters that define the source and destination databases, table, and other settings.


public async Task SyncTable(string connectionString, string destinationConnectionString, string tableName, string schema, Func<dynamic, bool> filterExpression = null, List<string> columns = null, bool bulkInsert = true , string whereClause = null, string orderByClause = null, int? top = null)

Inside the method, two SqlConnection objects are created for the source and destination databases.


using SqlConnection sourceConnection = new SqlConnection(connectionString);
using SqlConnection destinationConnection = new SqlConnection(destinationConnectionString);

The next step is to get the matched columns from the source and destination databases, as well as the primary key columns for the destination table.


string[] sourceColumns = await GetMatchedColumns(sourceConnection, null, tableName, schema) ?? Array.Empty<string>();
string[] destinationColumns = await GetMatchedColumns(destinationConnection, sourceColumns, tableName, schema) ?? Array.Empty<string>();
IEnumerable<string> primaryKeyColumns = columns ?? await GetPrimaryKeyColumns(destinationConnection, tableName, schema);

A SELECT statement is built using the source table and columns, as well as any additional filter expressions, sorting, or limit settings specified in the input parameters.


var selectCommand = BuildSelectCommand(sourceColumns, tableName, schema , whereClause , orderByClause , top , primaryKeyColumns);

If a filter expression is provided, it is appended to the SELECT statement.


if (filterExpression != null)
{
    selectCommand += $" WHERE {filterExpression.Method.Name}()";
}

The SELECT statement is executed against the source database, and the resulting entities are stored in a List.


List<dynamic> sourceEntities = (await sourceConnection.QueryAsync<dynamic>(selectCommand)).ToList();

If there are no entities returned from the SELECT statement, the method returns without further action.


if (!(sourceEntities?.Any() ?? false))
{
    return;
}

The existing primary key values for the destination table are retrieved and stored in a List.


var existingDestinationIds = await destinationConnection.QueryAsync<dynamic>($"SELECT {string.Join(", ", primaryKeyColumns)} FROM {schema}.{tableName}");
var existingDestinationKeys = existingDestinationIds.ToList();

The source entities are filtered to remove any that already exist in the destination table, based on matching primary key values.


var filteredSourceEntities = sourceEntities.Where(x =>
{
    var xDict = x as IDictionary<string, object>;
    return xDict != null && !existingDestinationKeys.Any(y =>
    {
        var yDict = y as IDictionary<string, object>;
        return yDict != null && primaryKeyColumns.All(k => xDict[k].Equals(yDict[k]));
    });
}).ToList();

If there are any filtered source entities remaining, they are either bulk copied to the destination table using SqlBulkCopy, or inserted one at a time, depending on the input parameter settings.


if (filteredSourceEntities?.Any() ?? false)
{
    if (bulkInsert)
    {
        SqlBulkCopy sqlBulkCopy = await BulkCopyAsync(tableName, schema, destinationConnectionString, destinationConnection, sourceColumns, destinationColumns, filteredSourceEntities);
    }
    else
    {
        await CopyOneByOneAsync(tableName, schema, destinationConnection, destinationColumns, filteredSourceEntities);
    }
}

It's important to note that the code snippet provided is just an example of how data synchronization can be achieved using Dapper and bulk insert. Depending on your specific use case, there may be other ways to achieve data synchronization, such as using SQL's MERGE statement to update or insert records.

There are also other useful tools and references available for data synchronization, such as Microsoft's Sync Framework and third-party tools like SymmetricDS and Flyway. These tools offer additional functionality and can be used to synchronize data across multiple databases, servers, and platforms.

In conclusion, data synchronization is an essential component of modern software systems, and using a service like dataSync can help ensure smooth and error-free data transfer between databases. By understanding the key concepts and best practices of data synchronization, developers can build robust and reliable applications that meet the needs of their users.
Code Example

10 Tips for debugging .NET applications with SQL Server

2023-02-18T23:27:00.002-08:00

Understand the application flow: Before you start debugging, make sure you understand the flow of the application and how it interacts with the SQL Server database. This will help you identify the parts of the code that might be causing issues.
Check the SQL Server error log: If you're experiencing database-related issues, check the SQL Server error log for any error messages or warnings that might give you clues about what's going wrong.
Use SQL Server Profiler: SQL Server Profiler is a powerful tool that can help you capture and analyze the activity between your .NET application and the SQL Server database. Use it to identify queries that are taking a long time to execute, or to see what data is being returned by the database.
Monitor SQL Server performance counters: SQL Server provides a wide range of performance counters that can help you monitor the health of your database server. Use them to identify performance bottlenecks or to track changes in resource usage over time.
Use SQL Server Management Studio: SQL Server Management Studio is a powerful tool that can help you manage your SQL Server instances and databases. Use it to run queries, view server logs, and analyze performance data.
Use the Visual Studio debugger: The Visual Studio debugger is an essential tool for debugging .NET applications. Use it to step through your code and identify where things might be going wrong.
Enable tracing in your .NET application: You can enable tracing in your .NET application to capture detailed information about what's happening at runtime. This can help you identify issues that might not be apparent from the code alone.
Check for exceptions: Make sure you're handling exceptions correctly in your .NET application. Unhandled exceptions can cause your application to crash, and they can also lead to issues with your SQL Server database.
Use the SQL Server Management Objects (SMO) API: The SMO API provides a way to programmatically manage SQL Server instances and databases. Use it to automate tasks, such as creating backups or managing users and permissions.
Use a third-party tool: There are many third-party tools available that can help you debug .NET applications with SQL Server. These tools often provide additional functionality, such as performance profiling or advanced query analysis.

Remember that debugging can be a time-consuming and complex process. Be patient, take your time, and don't be afraid to ask for help if you're stuck.

A Beginner's Guide to Building RESTful APIs with .NET Core and SQL Server

2023-02-18T22:47:00.004-08:00

If you're a .NET developer who wants to build web applications or mobile apps that require data access, you'll need to build an API. RESTful APIs have become the de-facto standard for web APIs, as they offer a flexible and standardized way for client applications to interact with server resources.

In this beginner's guide, we'll walk you through the process of building a RESTful API with .NET Core and SQL Server. We'll cover the basic concepts of RESTful APIs, as well as the tools and techniques you'll need to get started. By the end of this article, you'll have a solid understanding of how to design and build RESTful APIs with .NET Core and SQL Server, and you'll be ready to start building your own APIs.

Let's get started!

Understanding RESTful APIs:

RESTful APIs are a popular way to create web services that can be accessed by other applications. REST, which stands for Representational State Transfer, is a set of architectural principles that guide the design of web applications. RESTful APIs are built using these principles and are typically based on HTTP. In order to build a RESTful API, it's important to understand the basic principles of RESTful design.

Some key concepts include: Resources: RESTful APIs are built around resources, which are typically identified by URLs. Each resource should have a unique URL, and it should be possible to interact with that resource using standard HTTP methods. HTTP Methods: RESTful APIs use HTTP methods to indicate what action should be taken on a resource.

Some common HTTP methods include GET (for retrieving data), POST (for creating new resources), PUT (for updating existing resources), and DELETE (for deleting resources). Status Codes: RESTful APIs use HTTP status codes to indicate the outcome of a request. For example, a 200 status code indicates that a request was successful, while a 404 status code indicates that the requested resource was not found. By understanding these basic principles of RESTful API design, you'll be able to create a web service that is easy to use and understand, and that can be accessed by a wide range of applications.
Setting up the Development Environment:

Before you can start building a RESTful API with .NET Core and SQL Server, you'll need to set up your development environment.

Here are the steps you'll need to follow:

Install .NET Core SDK: The .NET Core SDK is a set of tools and libraries that you'll need in order to build .NET Core applications. You can download the SDK from the official .NET website (https://dotnet.microsoft.com/download).

Install Visual Studio or Visual Studio Code: Visual Studio is a popular IDE for .NET development, while Visual Studio Code is a lightweight code editor that is also a good option for .NET development.
You can download Visual Studio from the official Microsoft website (https://visualstudio.microsoft.com/downloads/), or Visual Studio Code from the official website (https://code.visualstudio.com/download).

Create a new .NET Core Web API project: Once you have your development environment set up, you can create a new .NET Core Web API project.
This can be done using either Visual Studio or Visual Studio Code. When creating the project, make sure to select the "Web API" template.
Add necessary NuGet packages to the project: In order to work with SQL Server in your .NET Core Web API project, you'll need to add some NuGet packages.

These packages provide the necessary libraries and tools for working with SQL Server.
Some common packages include Microsoft.EntityFrameworkCore.SqlServer, Microsoft.AspNetCore.Mvc.NewtonsoftJson, and Microsoft.AspNetCore.Authentication.JwtBearer.
Designing the API:

Once you have your development environment set up, the next step is to design your API.
This involves defining the resources and endpoints of the API, as well as creating data models and configuring data access with Entity Framework Core.

Here are some examples of what you might do:

Define the resources and endpoints of the API:
Let's say you're building an e-commerce application.
Some of the resources you might define include customers, orders, and products.
For each resource, you'll need to decide what endpoints will be available.
For example, for the customers resource, you might have endpoints for getting a list of customers, creating a new customer, updating an existing customer, and deleting a customer.

Create data models:
Continuing with the e-commerce example, you'll need to create data models that represent the data you'll be working with.
For the customers resource, you might have a Customer class that has properties such as Id, FirstName, LastName, and EmailAddress.

Similarly, for the orders resource, you might have an Order class that has properties such as Id, CustomerId, OrderDate, and TotalAmount.

Configure data access with Entity Framework Core:
In order to access the data in your database, you'll need to configure Entity Framework Core. This involves creating a database context, which is a class that represents the database and provides access to the data. For example, you might create a class called MyDbContext that derives from DbContext and has properties for each of your data models (e.g., DbSet<Customer>, DbSet<Order>).

You'll also need to configure the database connection string, which tells Entity Framework Core where to find the database. By following these examples, you'll have a better understanding of how to design your RESTful API with .NET Core and SQL Server.

An example implementation of a CRUD (Create, Read, Update, Delete) operation for a Customer resource using .NET Core and SQL Server:

Define the Customer data model:


public class Customer
    {
        public int Id { get; set; }
        public string FirstName { get; set; }
        public string LastName { get; set; }
        public string EmailAddress { get; set; }
    }

Create a database context:


public class MyDbContext : DbContext
    {
        public DbSet<Customer> Customers { get; set; }
        
        protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
        {
            optionsBuilder.UseSqlServer("connection_string_here");
        }
    }

Create a Customer controller:


[ApiController]
    [Route("[controller]")]
    public class CustomersController : ControllerBase
    {
        private readonly MyDbContext _context;
        
        public CustomersController(MyDbContext context)
        {
            _context = context;
        }
        
        [HttpGet]
        public IEnumerable<Customer> Get()
        {
            return _context.Customers.ToList();
        }
        
        [HttpGet("{id}")]
        public Customer Get(int id)
        {
            return _context.Customers.Find(id);
        }
        
        [HttpPost]
        public void Post(Customer customer)
        {
            _context.Customers.Add(customer);
            _context.SaveChanges();
        }
        
        [HttpPut("{id}")]
        public void Put(int id, Customer customer)
        {
            var existingCustomer = _context.Customers.Find(id);
            existingCustomer.FirstName = customer.FirstName;
            existingCustomer.LastName = customer.LastName;
            existingCustomer.EmailAddress = customer.EmailAddress;
            _context.SaveChanges();
        }
        
        [HttpDelete("{id}")]
        public void Delete(int id)
        {
            var customer = _context.Customers.Find(id);
            _context.Customers.Remove(customer);
            _context.SaveChanges();
        }
    }

This controller defines endpoints for each of the CRUD operations on the Customer resource. The [HttpGet] attribute is used for the Get method, which returns a list of all customers.

The [HttpGet("{id}")] attribute is used for the Get(int id) method, which returns a single customer with the specified ID.

The [HttpPost] attribute is used for the Post method, which adds a new customer to the database.

The [HttpPut("{id}")] attribute is used for the Put(int id, Customer customer) method, which updates an existing customer.

The [HttpDelete("{id}")] attribute is used for the Delete(int id) method, which deletes a customer with the specified ID.

4. Implementing Authentication and Authorization:

Secure the API endpoints with authentication and authorization. Use JSON Web Tokens (JWT) for authentication and role-based access control for authorization.

Install the necessary NuGet packages for authentication and authorization. You can use packages such as Microsoft.AspNetCore.Authentication.JwtBearer and Microsoft.AspNetCore.Authorization.
Configure authentication and authorization in your project's startup file. You'll need to set up the authentication scheme, define the authorization policies, and add the necessary middleware.
Create a login endpoint where users can authenticate and receive a JWT. This involves validating the user's credentials and generating a token with a secret key.
Set up role-based access control by defining roles and policies in your project's authorization configuration. You can then use the [Authorize] attribute on your API endpoints to restrict access based on these roles.
Test your authentication and authorization by making requests to your API endpoints with a valid JWT and testing both authorized and unauthorized scenarios.

An example implementation of a login endpoint for a .NET Core Web API with JWT authentication:

First, add the necessary NuGet packages to the project:
- Microsoft.AspNetCore.Authentication.JwtBearer
- Microsoft.IdentityModel.Tokens
Define a user model to represent users in the system, for example:


public class User
    {
        public int Id { get; set; }
        public string Username { get; set; }
        public string Password { get; set; }
        public string Role { get; set; }
    }

Configure authentication in the Startup.cs file by adding the following code in the ConfigureServices method:


services.AddAuthentication(options =>
    {
        options.DefaultAuthenticateScheme = JwtBearerDefaults.AuthenticationScheme;
        options.DefaultChallengeScheme = JwtBearerDefaults.AuthenticationScheme;
    })
    .AddJwtBearer(options =>
    {
        options.TokenValidationParameters = new TokenValidationParameters
        {
            ValidateIssuer = true,
            ValidateAudience = true,
            ValidateLifetime = true,
            ValidateIssuerSigningKey = true,
            ValidIssuer = Configuration["Jwt:Issuer"],
            ValidAudience = Configuration["Jwt:Issuer"],
            IssuerSigningKey = new SymmetricSecurityKey(Encoding.UTF8.GetBytes(Configuration["Jwt:Key"]))
        };
    });

Make sure to add the JWT settings to your appsettings.json file.

Create a TokenController to handle authentication requests and generate JWT tokens:


[Route("api/[controller]")]
    [ApiController]
    public class TokenController : ControllerBase
    {
        private readonly IConfiguration _configuration;
    
        public TokenController(IConfiguration configuration)
        {
            _configuration = configuration;
        }
    
        [AllowAnonymous]
        [HttpPost]
        public IActionResult GenerateToken([FromBody] UserDto userDto)
        {
            // Authenticate user
            var user = AuthenticateUser(userDto.Username, userDto.Password);
            if (user == null)
            {
                return Unauthorized();
            }
    
            // Generate token
            var tokenHandler = new JwtSecurityTokenHandler();
            var key = Encoding.UTF8.GetBytes(_configuration["Jwt:Key"]);
            var tokenDescriptor = new SecurityTokenDescriptor
            {
                Subject = new ClaimsIdentity(new Claim[]
                {
                    new Claim(ClaimTypes.Name, user.Id.ToString()),
                    new Claim(ClaimTypes.Role, user.Role)
                }),
                Expires = DateTime.UtcNow.AddDays(7),
                SigningCredentials = new SigningCredentials(new SymmetricSecurityKey(key), SecurityAlgorithms.HmacSha256Signature)
            };
            var token = tokenHandler.CreateToken(tokenDescriptor);
    
            return Ok(new { token = tokenHandler.WriteToken(token) });
        }
    
        private User AuthenticateUser(string username, string password)
        {
            // TODO: Authenticate user from database or other data source
            return new User { Id = 1, Username = "test", Password = "test", Role = "admin" };
        }
    }
    
    public class UserDto
    {
        public string Username { get; set; }
        public string Password { get; set; }
    }

Protect the endpoints that require authentication by adding the [Authorize] attribute to the controller or action:


[Authorize(Roles = "admin")]
    [HttpGet]
    public IActionResult Get()
    {
        // TODO: Return data from database or other data source
        return Ok(new List<string> { "value1", "value2" });
    }

Make sure to properly secure your system and use best practices for authentication and authorization in production environments.

5. Testing the API:

Once you have implemented your API, it is important to test it thoroughly to ensure it works as expected. You can write unit tests and integration tests for the API using a testing framework such as NUnit or xUnit.

Unit tests allow you to test individual components of the API in isolation, while integration tests test how these components work together. By writing tests for your API, you can catch bugs and issues early in the development process.

You can also use tools like Postman to test the API endpoints manually. Postman allows you to send requests to your API and inspect the responses. This can be useful for testing specific scenarios or edge cases that may not be covered by your automated tests.

By testing your API thoroughly, you can ensure that it is reliable and performs well in a production environment.

An example of how you can write unit tests and integration tests for your .NET Core Web API:

Unit Tests:
Let's say you have a UserController in your API that handles CRUD operations for users. You can write unit tests to test the methods in this controller.

[TestFixture]
    public class UserControllerTests
    {
        private UserController _controller;
    
        [SetUp]
        public void Setup()
        {
            // Arrange
            var mockRepository = new Mock<IUserRepository>();
            _controller = new UserController(mockRepository.Object);
        }
    
        [Test]
        public void GetUsers_ReturnsListOfUsers()
        {
            // Act
            var result = _controller.GetUsers();
    
            // Assert
            Assert.IsInstanceOf<IEnumerable<User>>(result);
        }
    
        [Test]
        public void GetUser_ReturnsUserById()
        {
            // Arrange
            var mockRepository = new Mock<IUserRepository>();
            var user = new User { Id = 1, Name = "John Doe" };
            mockRepository.Setup(repo => repo.GetUserById(user.Id)).Returns(user);
            var controller = new UserController(mockRepository.Object);
    
            // Act
            var result = controller.GetUser(user.Id);
    
            // Assert
            Assert.AreEqual(user, result);
        }
    
        // Other tests for Create, Update, and Delete methods
    }

In this example, we are using the NUnit testing framework to write unit tests for the UserController. We are mocking the IUserRepository interface to simulate database operations.

Integration tests:
Integration tests allow you to test how different components of your API work together. For example, you can test how your API handles requests and responses, and how it interacts with a database.


[TestFixture]
    public class UserControllerIntegrationTests
    {
        private HttpClient _client;
        private AppSettings _appSettings;
    
        [SetUp]
        public void Setup()
        {
            // Arrange
            var factory = new WebApplicationFactory<Startup>()
                .WithWebHostBuilder(builder =>
                {
                    builder.ConfigureTestServices(services =>
                    {
                        // Override app settings for testing
                        _appSettings = new AppSettings { Secret = "test_secret" };
                        services.Configure<AppSettings>(options => options = _appSettings);
                    });
                });
    
            _client = factory.CreateClient();
        }
    
        [Test]
        public async Task GetUsers_ReturnsListOfUsers()
        {
            // Act
            var response = await _client.GetAsync("/api/users");
    
            // Assert
            response.EnsureSuccessStatusCode();
            var users = await response.Content.ReadAsAsync<IEnumerable<User>>();
            Assert.IsTrue(users.Any());
        }
    
        [Test]
        public async Task Authenticate_ReturnsJwtToken()
        {
            // Arrange
            var login = new LoginDto { Username = "testuser", Password = "testpass" };
            var content = new StringContent(JsonConvert.SerializeObject(login), Encoding.UTF8, "application/json");
    
            // Act
            var response = await _client.PostAsync("/api/authenticate", content);
    
            // Assert
            response.EnsureSuccessStatusCode();
            var token = await response.Content.ReadAsStringAsync();
            Assert.IsFalse(string.IsNullOrEmpty(token));
        }
    
        // Other integration tests for Create, Update, and Delete endpoints
    }

In this example, we are using the WebApplicationFactory class provided by ASP.NET Core to create an instance of our API for testing. We are then using the HttpClient to send requests to our API and inspect the responses.

Deploying the API:

Once you have developed and tested your RESTful API, it's time to deploy it to a hosting environment where it can be accessed by your clients or users. There are various hosting solutions available, such as Azure App Service, AWS Elastic Beanstalk, or Docker containers, depending on your needs and preferences.

To deploy your API to Azure App Service, you can follow these general steps:

- Create an Azure App Service resource in your Azure portal.
- Configure the App Service plan, runtime stack, and other settings based on your requirements.
- Create a deployment package of your API project using Visual Studio or command-line tools like dotnet CLI.
- Upload and deploy the deployment package to the App Service using FTP, Git, or other deployment options.
- Configure the App Service environment variables, connection strings, and other settings that your API requires.
- Test the deployed API to ensure it's working as expected.

If you prefer to use Docker containers for hosting your API, you can follow these steps:

- Install Docker on your local machine or the server that you want to use as the host.
- Build a Docker image of your API project using the Dockerfile that defines the dependencies and configuration of your project.
- Push the Docker image to a container registry such as Docker Hub or Azure Container Registry.
- Create a container instance from the Docker image in the host environment using tools like Docker Compose, Kubernetes, or Azure Container Instances.
- Configure the container instance settings such as environment variables, ports, and volumes.
- Test the deployed API to ensure it's accessible from other machines or services.

with some practice and guidance, you can learn how to deploy your API with confidence and efficiency.

In conclusion, building a RESTful API with .NET Core and SQL Server is a powerful way to create scalable and secure web services. By following the steps outlined in this guide, you can create a robust API that meets your needs.

To help you in your API development journey, here are some useful tools and resources:

- Swagger UI: A popular tool for generating interactive API documentation.
- Postman: A popular tool for testing APIs.
- IdentityServer4: A library for implementing authentication and authorization in .NET Core APIs.
- Entity Framework Core: A popular object-relational mapper (ORM) for .NET Core that simplifies data access.
- .NET Core CLI: A command-line interface for managing .NET Core projects and tools.

For more information on building RESTful APIs with .NET Core and SQL Server, check out these resources:

- Microsoft's official documentation on .NET Core and ASP.NET Core: https://docs.microsoft.com/en-us/dotnet/core/
- RESTful API Design: Best Practices by Microsoft: https://docs.microsoft.com/en-us/azure/architecture/best-practices/api-design
- Building RESTful Web APIs with ASP.NET Core 3 by Jason Roberts: https://www.pluralsight.com/courses/aspdotnet-core-3-restful-web-apis

We hope this guide has been helpful in getting you started with building RESTful APIs with .NET Core and SQL Server. Good luck with your API development!

Recursive algorithms

2017-10-06T09:52:00.001-07:00

Recursion

In this article
1- What is a Recursive function and the problem it solve?
2- Example Computing Powers .

Recursive function

A Recursive function is a function that calls itself ether directly or indirectly through another function .A Recursive function is called to solve a problem by solving a smaller instance of the same problem unless it is the simplest case(s) or so-called base case(s) it will return the result.

Example Computing Powers

1 - The simplest case when you want to compute x^n is when n = 0 the result always be 1 no matter what x is .

function CopmutePower(x , n){

if (n == 0){

return 1;
}

}

2 - The second case we can think about is when n is positive

when you multiply powers of x you add the exponents: x^a * x^b = x^(a+b)
eg. 2^2 × 2^4 = 2^(2+4) = 64.

If n is positive and even then x^n = x^(n/2) * x^(n/2)
eg. 2^6 = 2^(6/2) * 2^(6/2) = 64 and for y= x^(n/2) Therefore x^n = y * y

function CopmutePower(x , n){

// n = 0 Simplest case(base case)

if (n == 0){

return 1;
}

// n is positive even

if (n % 2 == 0){

var y = CopmutePower(x, n / 2);

return y * y;

}

3 -If n is positive and odd then x^n = x^(n−1) * x in this case if n-1 = 0 then it will be the base case when n = 0 and if n-1 is positive and even then it will be the second case .
Therefor you could compute those cases recursively

function CopmutePower(x , n){

// n = 0 Simplest case(base case)

if (n == 0){

return 1;
}

// n is positive and even

if (n % 2 == 0){

var y = CopmutePower(x, n / 2);

return y * y;

}

// n is positive and even

if (!(n % 2 == 0)){

return x * CopmutePower(x, n - 1);

}

4 - If n is negative then x^n = 1 / (x^n)

function CopmutePower(x , n){

// n = 0 Simplest case(base case)

if (n == 0){

return 1;
}

// n is positive and even

if (n % 2 == 0){

var y = CopmutePower(x, n / 2);

return y * y;

}

// n is positive and even

if (!(n % 2 == 0)){

return x * CopmutePower(x, n - 1);

}

// n is negative
if (n < 0){

return 1 / CopmutePower(x, -n);

}

-- JavaScript Code

See the Pen Recursive powers by Mohamed Salah (@saad306) on CodePen.

-- C# Code

Algorithm - Insertion Sort

2017-08-22T10:51:00.001-07:00

In this article
What is an Insertion sort
Implement Insertion sort - Demo (JavaScript - C#)

1 - What is an Insertion Sort

It is a sorting algorithm which sorts each Item in the list or array by shifting elements as they're encounter(one by one.)

In insertion sort we loop over an array from left to right and we compare current item in the iteration to it's left if it's less than pull it out and move the left index to the right then Insert current item to the sorted place . so everything left to the CurrentItem in the iteration Is sorted.

So let's see a sample implementation.

JavaScript .

See the Pen insertion sort by Mohamed Salah (@saad306) on CodePen.

JavaScript Prototypes and Inheritance

2016-11-19T09:27:00.004-08:00

In this article
what's JavaScript prototypes
JavaScript Inheritance

1 - What's JavaScript prototypes

JavaScript uses prototypes where many other object-oriented languages use classes for inheritance . It is possible to simulate many class-based features with prototypes in JavaScript .wikipedia

All JavaScript objects inherit the properties and methods from their prototype. Objects created using an object literal, or with new Object(), inherit from a prototype called Object.prototype. Objects created with new Date() inherit the Date.prototype. The Object.prototype is on the top of the prototype chain.w3schools

You can consider a prototype is a pointer to a base Object when you create a new instance of that Object , and this mean if you change a prototype property of an object it will affect all objects constructed using that object.

So let's see example and Create a new object and a new instance of it.

Create object and new instance of it.

Note : that every constructed function has a property called __proto__ , and you can use it to access base object prototype property as shown below.

function employee(name, salary) {

this.Name = name;

this.salay = salary

}

//Create prototype transportAllowance property.

employee.prototype.transportAllowance = 500;

// new instance of employee

var emp = new employee('Ahmed', 5000);

// Create transportAllowance property of emp.

emp.transportAllowance = 400;

document.write(emp.transportAllowance + '<br/>'); //Output 400

document.write(emp.__proto__.transportAllowance + '<br/>'); //output 50

2 - JavaScript Inheritance

Inheritance is the ability to create a class from another class, the "parent" class, extending the functionality and state of the parent in the derived, or "child" class. It allows derived classes to overload methods from their parent class.
Inheritance is one of the pillars of object-orientation. It is the mechanism of designing one class from another and is one of the ideas for code reusability, supporting the concept of hierarchical classification. C# programs consist of classes, where new classes can either be created from scratch or by using some or all properties of an existing class.
Another feature related to inheritance and reusability of code is polymorphism, which permits the same method name to be used for different operations on different data types. Thus, C# supports code reusability by both features. wiki

JavaScript is a bit confusing for developers experienced in class-based languages (like Java or C++), as it is dynamic and does not provide a class implementation per se (the class keyword is introduced in ES6, but is syntactical sugar, JavaScript remaining prototype-based).
When it comes to inheritance, JavaScript only has one construct: objects. Each object has an internal link to another object called its prototype. That prototype object has a prototype of its own, and so on until an object is reached with null as its prototype. null, by definition, has no prototype, and acts as the final link in this prototype chain.
While this is often considered to be one of JavaScript's weaknesses, the prototypal inheritance model is in fact more powerful than the classic model. It is, for example, fairly trivial to build a classic model on top of a prototypal model, while the other way around is a far more difficult task. developer.mozilla

let's see example in how to apply inheritance in JavaScript.

Creating Prototypal Inheritance Chains

//use this as a base function

function Person(firstName, lastName) {

this.FirstName = firstName,

this.LastName = lastName,

this.FullName = function () {

return this.FirstName + ' ' + this.LastName

}

//and this is a derived function that inherited from Person function above

function employee(firstName, lastName, department, salary) {

//Call Person

Person.call(this, firstName, lastName);

this.Department = department,

this.salay = salary,

this.showInfo = function () {

return 'Name: ' + this.FirstName + ' ' + this.LastName

+ '<br/>' + 'Department: ' + this.Department

+ '<br/>' + 'Salary: ' + this.salay

};

}

//inherit Person

employee.prototype = Object.create(Person.prototype);

//set employee constructor to itself

employee.prototype.constructor = employee;

document.write(new employee('Ahmed', 'Saad', 'HR', '5000').showInfo())

//output

//Name: Ahmed Saad

//Department: HR

//Salary: 5000

JavaScript Properties

2016-11-19T08:52:00.000-08:00

In this article
Bracket Notation for Properties
Using Descriptors property
Writable attribute
Using Enumerabe Attribute
Useing Configurable Attribute
Using get and set

1 - Bracket Notation for Properties

You can access property by using object followed by its property like this:

'use strict'

var employee = {

salary: '5000'

}

// use object followed by property

document.write(employee.name) // output Ahmed

Or by using bracket notation like this:

'use strict'

var employee = {

salary: '5000'

}

// bracket notation

document.write(employee['name']) // output Ahmed

Also you can define a new property like this:

'use strict'

var employee = {

salary: '5000'

}

//assign new property

employee['lastName'] = 'Saad';

// bracket notation

document.write(employee['lastName']) // output Saad

2 - Using Descriptors property

Beside name and value every property has a property Descriptor.

Use property Descriptor to see attributes of that property.

Every property has attributes value , writable , enumerable and configurable attributes and by default it's all set to true.

You can see attributes by looping over Object.getOwnPropertyDescriptor() property like this:

'use strict'

var employee = {

salary: '5000'

}

// looping over Object.getOwnPropertyDescriptor()

for (var property in Object.getOwnPropertyDescriptor(employee, 'name')) {

document.write(property + ' ' + Object.getOwnPropertyDescriptor(employee, 'name')[property])

document.write('<br/>')

}

//Output

//value Ahmed

//writable true

//enumerable true

//configurable true

3 - Writable attribute

You can use writable attribute to define whether the value of property can be changed from initial value or not.

You can change the value of writable attribute by using Object.defineProperty() like this :

'use strict'

var employee = {

salary: '5000'

}

Object.defineProperty(employee, 'name', { writable: false });

//trying to alter name

employee['name'] = 'Saad'

document.write(employee['name']);

//Output

//If you go to developer tools in your browser you will see error like this

// " Uncaught TypeError: Cannot assign to read only property 'name' of #<Object> "

// Note : you have to use 'use strict'

You can not apply non-writable property if a property contains an object , you can use Object.freeze() instead like this :

'use strict'

var employee = {

firstName: 'Ahmed',

lastName: 'Saad'

salary: '5000'

}

Object.defineProperty(employee, 'name', { writable: false });

//trying to alter name.lastName

employee.name.lastName = 'Salah'

document.write(employee.name.lastName); //Output Salah

Object.freeze(employee.name);

//trying to alter name.lastName

employee.name.lastName = 'Saad';

document.write(employee.name.lastName);

//Output

//If you go to developer tools in your browser you will see error like this

// "Uncaught TypeError: Cannot assign to read only property 'lastName' of #<Object> "

// Note : you have to use 'use strict'

4 - Using Enumerabe Attribute

You can prevent property from being looping by setting enumerable attribute to false like this:

Note : If you set enumerable attribute to false it will affect when you try to serialize object to JSON

'use strict'

var employee = {

salary: '5000'

}

// looping over Object.getOwnPropertyDescriptor()

for (var property in employee) {

document.write(property + ' ' + employee[property])

document.write(' ')

} //Output value Ahmed , salary 5000

//new line

document.write('<br/>')

Object.defineProperty(employee, 'name', { enumerable: false });

for (var property in employee) {

document.write(property + ' ' + employee[property])

} //Output salary 5000

4 - Useing Configurable Attribute

Configurable Attribute can prevent an attribute from being changed or any property from being deleted from the object.

Use Object.defineProperty(Object, 'property' , {configurable : false}) to set value to false.

5 - Using get and set

You can use get and set to set or return value by using a function like this

'use strict'

var employee = {

firstName: 'Ahmed',

lastName: 'Saad'

salary: '5000'

}

Object.defineProperty(employee, 'fullName', {

get: function () {

return this.name.firstName + ' ' + this.name.lastName

}

});

document.write(employee.fullName) //output Ahmed Saad

// Note you can use same technique for set to set new value

Objects in JavaScript

2016-11-19T08:00:00.002-08:00

Objects in JavaScript

In this article
Create object by using JavaScript object literal
Using constructor to create Objects in JavaScript
Create object by using object.create()
Using ECMAScript 6 Classes to create javescript Objects

1 - Create object by using JavaScript object literal

You can create javascript Object literal like this.

//object literal

var employee = {

firstName: 'Ahmed',

lastName: 'Saad'

};

// you can call it like this

document.write(employee.firstName); //output : Ahmed

Add property to your Object .

//object literal

var employee = {

firstName: 'Ahmed',

lastName: 'Saad'

};

// add object property

employee.salary = 5000;a

document.write(employee.salary); //output : 5000

Add a Function to your Object .

//object literal

var employee = {

firstName: 'Ahmed',

lastName: 'Saad'

};

//Add Function

employee.fullName = function () {

document.write(this.firstName + ' ' + this.lastName)

// Note : this keyword refers to object itself

}

// call function like this

employee.fullName(); //Output : Ahmed Saad

Another way to add a Function to your Object , Add a Function inside your Object .

//object literal

var employee = {

firstName: 'Ahmed',

lastName: 'Saad',

fullName: function () {

document.write(this.firstName + ' ' + this.lastName)

// Note : this keyword refers to object itself

}

};

// call function like this

employee.fullName(); //Output : Ahmed Saad

2 - Using constructor to create Objects in JavaScript

If you want to create multi instance of an object you can use constructor to create Objects.

After createing constructor Object use new Keyword to create new instance of your objets.

Here is how to create constructor Object

//constructor object

function employee() {

this.firstName = 'Ahmed',

this.lastName = 'Saad'

};

//Create new instance

var emp = new employee();

// use it like this

document.write(emp.firstName) //Output : Ahmed

You can pass values of properties to function instead of hardcoded it.

your constructor function will look like this .

//constructor object with parameters

function employee(fName, lName) {

this.firstName = fName,

this.lastName = lName

};

//Create new instance and pass values

var emp = new employee('Ahmed', 'Saad');

// use it like this

document.write(emp.firstName) //Output : Ahmed

Add Function to your Object .

//constructor object with parameters and function

function employee(fName, lName) {

this.firstName = fName,

this.lastName = lName,

this.fullName = function () {

document.write(this.firstName + ' ' + this.lastName)

}

};

//Create new instance and pass values

var emp = new employee('Ahmed', 'Saad');

// use it like this

emp.fullName() //Output : Ahmed Saad

3 - Create object by using object.create()

The Object.create() method creates a new object with the specified prototype object and properties.

Here is how to create Object by using Object.create() method .

//use objact.create()

var employee = Object.create(Object.prototype,

{

firstName: {

value: 'Ahmed'

lastName: {

//go to JavaScript Object Properties Article for more details

writable: true,

configurable: true,

value: 'Saad'

}

);

document.write(employee.firstName)//Output : Ahmed

For more details about JavaScript Object Properties Click here

4 - Using ECMAScript 6 Classes to create javescript Objects

ECMAScript 6 provide functionality to use Class structure to Create object.

Note: Browser must support ECMAScript 6 , I used Microsoft Edge for this example.

Here is how to create Object by using class .

//Ecma Script 6 Classes

class Employee {

constructor(fName, lName) {

this.firstName = fName

this.lastName = lName

}

fullName() {

//new liine

document.write('<br\>');

document.write(this.firstName, ' ' + this.lastName)

}

var emp = new Employee('Ahmed', 'Saad');

//use it

document.write(emp.firstName) //Output : Ahmed

//call function

emp.fullName(); //Ourput : Ahmed Saad

Sort unordered list by JavaScript Array sort() Method

2016-11-19T07:09:00.001-08:00

Use JavaScript sort() Method

- This example show how to sort an unordered list by using array and for loop.

You will need to write your own html code to genrete ul.

here is a basic ul and sort button.

<ul>

<li>JavaScript</li>

</ul>

and here is this SortLang () function

function SortLang() {

var languages = [];

var items = document.getElementsByTagName("li");

for (var i = 0, l = items.length; i < l; i++) {

languages.push(items[i].innerHTML)

}

languages.sort();

for (var i = 0, l = items.length; i < l; i++) {

items[i].innerHTML = languages[i];

}

Try It

See the Pen XXWKmK by Mohamed Salah (@saad306) on CodePen.

How to Manipulate and fill HTML Table - JavaScript & jQuery

2016-11-19T06:51:00.002-08:00

Manipulate and fill HTML Table

1- Fill table by using jQuery append method.

Table Structure

<tr>

<th>First Name</th>

</tr>

</table>

Code to append data from json

var jsonNames = { "Mohamed": "saad", "joseph": "Dankwah", "Christian": "mensah" };

$.each(jsonNames, function (key, val) {

$("<tr><td>" + key + "</td><td>" + val + "</td</tr>").appendTo("#names")

});

See the Pen appendTo from json by Mohamed Salah (@saad306) on CodePen.

2- Fill table by retrieving data from user input .

Here is html structure

<div>

<label>First Name : <input id="frist-name" type="text" /></label>

</div>

<tr>

<th>First Name</th>

</tr>

</table>>

And your Code

function addname() {

var fName = $("#frist-name").val().toUpperCase();

var lName = $("#last-name").val().toUpperCase();

if (fName != "" && lName != "") {

$("<tr><td>" + fName + "</td><td>" + lName + "</td><td>" + fName + " " + lName + "</td></tr>").appendTo("#names")

}

Try It ..

See the Pen appendTo from input by Mohamed Salah (@saad306) on CodePen.

Getting Started - Create a SPA And use AngularJS $http Service

2016-11-18T07:25:00.000-08:00

AngularJS & Web API - SPA & $http

- This article is Part of a series :

After Configuration of our Web API in Library project(Getting Started - Web API) , Open project From the Tools menu click NuGet Package Manager and then click Package Manager Console. In the Package Manager Console write the following command:

PM> Install-Package angularjs

Also install bootstrap - we'll use it for styling

PM> Install-Package bootstrap

In project root add new html page named Index.html and add references to Bootstrap & AngularJS (from Scripts and Content folders) , Edit html to look like fallowing :

"This is page contain navigation bar and all references I needed so far

For more - See Also - How to Create a Single-Page Application (SPA) "

//Index.html

<!DOCTYPE html>

<head>

</head>

<body>

</button>

<a class="navbar-brand" href="#">Library</a>

</div>

<li><a href="#books">Books</a></li>

<li><a href="#authors">Author</a></li>

</ul>

</div>

</div>

</body>

</html>

add new folder named templates , In templates folder add 2 new paes named books.html & authors.html , in the books.html & & authors.html Edit dom to like like this:

//books.html

<div>

<thead>

<tr>

<th>

Book Name

</th>

<th>

Author

</th>

</tr>

</thead>

<tr>

<td>

</td>

<td>

</td>

</tr>

</tbody>

</table>

</div>

//authors.html

<div>

<thead>

<tr>

<th>

Author Name

</th>

<th>

Available books

</th>

</tr>

</thead>

<tr>

<td>

</td>

<td>

</td>

</tr>

</tbody>

</table>

</div>

Add new folder in Scripts folder named LibraryApp and add 4 JavaScript files named libraryModule.js , libraryService.js , booksController.js , authorsController.js) .

1- In libraryModule.js

//libraryModule.js

var libraryModule = angular.module("libraryModule", ['ngRoute'])

.config(function ($routeProvider) {

$routeProvider.when('/books', { templateUrl: '/templates/books.html', controller: 'booksController' });

$routeProvider.when('/authors', { templateUrl: '/templates/authors.html', controller: 'authorsController' });

//default

$routeProvider.otherwise({ templateUrl: '/templates/books.html', controller: 'booksController' });

});

2- In libraryService

"See also - Getting Started - Web API"

//libraryService.js

libraryModule.factory('libraryService',function ($http, $q) {

var svc = {

getAllBooks: function () {

var deferred = $q.defer();

$http.get('/api/books')

.success(deferred.resolve)

.error(deferred.reject);

return deferred.promise;

getAllAuthors: function () {

var deferred = $q.defer();

$http.get('/api/authors')

.success(deferred.resolve)

.error(deferred.reject);

return deferred.promise;

}

};

return svc;

})

3- In booksController.js

//booksController.js

libraryModule.controller("booksController", function ($scope, libraryService) {

$scope.books = [];

var getAllBooks = function () {

libraryService.getAllBooks().then(

function (books) {

$scope.books = books;

function (error) {

console.log('Error', error);

});

}();

});

4- In authorsController.js

//authorsController.js

libraryModule.controller("authorsController", function ($scope, libraryService) {

$scope.authors = [];

var getAllAuthors = function () {

libraryService.getAllAuthors().then(

function (authors) {

$scope.authors = authors;

function (error) {

console.log('Error', error);

});

}();

});

- That is all ! - Now run your project and go to Index page to see your work .

Index Page

- link to project in github.

Getting Started - Web API

2016-11-17T09:31:00.000-08:00

ASP.NET Web API

- This article is Part of a series :

After created data model in Library project - From solution explorer right click on your project , select Add, then select new Scaffolded Item , select Web API Controller - Empty, In the Add Controller dialog name the controller BooksController (Web API controllers inherit the ApiController class that handles HTTP requests).

Add new folder named ViewModels , In ViewModels folder add new class Named BooksVm and class named AuthorVm Write the following :

"You can consider using of viewModels classes as data transfer object(DTO)

this is to avoid circular references becouese of navagtion property in Author class

also you may need to hide or add some new property. see also"

//BookVm.cs

namespace Library.ViewModels

{

public class BookVm

{

public int BookId { get; set; }

public string BookName { get; set; }

public int AuthorId { get; set; }

public string AuthorName { get; set; }

}

//AuthorVm.cs

namespace Library.ViewModels

{

public class AuthorVm

{

public int AuthorId{ get; set; }

public string AuthorName { get; set; }

public int BookCount { get; set; }

}

Back to Controllers ,ِRight click in Controllers folder and Add new Web API Controller - Empty, In the Add Controller dialog name the controller AuthorsController

Add the following methods(These methods implement GET , Post request) to BooksController.cs and AuthorsController.cs

//BooksController.cs

namespace Library.Controllers

{

[Route("api/books")]

public class BooksController : ApiController

{

LibraryDbContext db = new LibraryDbContext();

public IQueryable<BookVm> GetBooks()

{

var books = from book in db.Books

select new BookVm

{

BookId = book.BookId,

BookName = book.BookName,

AuthorId = book.AuthorId,

AuthorName = book.Author.AuthorName

};

return books;

}

//AuthorController.cs

namespace Library.Controllers

{

[Route("api/authors")]

public class AuthorsController : ApiController

{

LibraryDbContext db = new LibraryDbContext();

public IQueryable<AuthorVm> GetBooks()

{

var authors = from author in db.Authors

select new AuthorVm

{

AuthorId = author.AuthorId,

AuthorName = author.AuthorName,

BookCount = author.Books.Count()

};

return authors;

}

Now we have "Get method" in each controller , Run your project to test get request e.g. http://localhost:xxxx/api/books or http://localhost:xxxx/api/authors .

to configure retrieved formatter for the JSON data to retrieve Json "Camel case" , In the App_Start folder open WebApiConfig.cs And add the following code to Register method :

//WebApiConfig.cs

var json = config.Formatters.JsonFormatter;

json.SerializerSettings.ContractResolver = new CamelCasePropertyNamesContractResolver();

- link to project in github.

Getting Started - Entity Framework Code First

2016-11-15T14:22:00.001-08:00

Entity Framework Code First

- This article is Part of a series :

open visual studio and Create a new web application named Library

Select Empty template and click OK

From the Tools menu click NuGet Package Manager and then click Package Manager Console. In the Package Manager Console write the following command:

PM> Install-Package EntityFramework

- Create the Data Model

add new folder named Models then Create 2 classes named Author.cs and Book.cs and write the following Code :

//Author.cs

using System;

using System.Collections.Generic;

namespace Library.Models

{

public class Author

{

public int AuthorId { get; set; }

public string AuthorName { get; set; }

public virtual ICollection<Book> Books { get; set; }

}

//Book.cs

namespace Library.Models

{

public class Book

{

public int BookId { get; set; }

public string BookName { get; set; }

public int AuthorId { get; set; }

public virtual Author Author { get; set; }

}

- Create the Database Context

Create new folder named DataLayer and add new class named LibraryDbContext.cs and write the following Code :

//LibraryDbContext.cs

using Library.Models;

using System;

using System.Collections.Generic;

using System.Data.Entity;

namespace Library.DataLayer

{

public class LibraryDbContext : DbContext

{

public LibraryDbContext()

: base("DefaultConnection")

{

}

public DbSet<Book> Books { get; set; }

public DbSet<Author> Authors { get; set; }

public static LibraryDbContext Create()

{

return new LibraryDbContext();

}

From the Tools menu click NuGet Package Manager and then click Package Manager Console. In the Package Manager Console write the following command:

PM> Enable-Migrations

After enabling migrations has done add to seed method in Configuration class follwing :

//Configuration.cs

protected override void Seed(Library.DataLayer.LibraryDbContext context)

{

context.Authors.AddOrUpdate(a => a.AuthorName, new Author { AuthorName = "Stephen Hawking" });

context.Authors.AddOrUpdate(a => a.AuthorName, new Author { AuthorName = "Elisabeth Kübler-Ross" });

context.Authors.AddOrUpdate(a => a.AuthorName, new Author { AuthorName = "Tony Crilly" });

context.SaveChanges();

context.Books.AddOrUpdate(a => a.BookName, new Book { BookName = "A brief history of time" , AuthorId = context.Authors.Single(a => a.AuthorName == "Stephen Hawking").AuthorId });

context.Books.AddOrUpdate(a => a.BookName, new Book { BookName = "Death: The Final Stage of Growth" , AuthorId = context.Authors.Single(a => a.AuthorName == "Elisabeth Kübler-Ross").AuthorId });

context.Books.AddOrUpdate(a => a.BookName, new Book { BookName = "50 Mathematical Ideas You Really Need to Know" , AuthorId = context.Authors.Single(a => a.AuthorName == "Tony Crilly").AuthorId });

context.Books.AddOrUpdate(a => a.BookName, new Book { BookName = "The Grand Design" , AuthorId = context.Authors.Single(a => a.AuthorName == "Stephen Hawking").AuthorId });

}

PM> Add-Migration initial-libraryDbContext

In the generated migration class turn cascadeDelete to false

//initiallibraryDbContext

public partial class initiallibraryDbContext : DbMigration

{

public override void Up()

{

CreateTable(

"dbo.Authors",

c => new

{

AuthorId = c.Int(nullable: false, identity: true),

AuthorName = c.String(),

})

.PrimaryKey(t => t.AuthorId);

CreateTable(

"dbo.Books",

c => new

{

BookId = c.Int(nullable: false, identity: true),

BookName = c.String(),

AuthorId = c.Int(nullable: false),

})

.PrimaryKey(t => t.BookId)

.ForeignKey("dbo.Authors", t => t.AuthorId, cascadeDelete: false)

.Index(t => t.AuthorId);

}

public override void Down()

{

DropForeignKey("dbo.Books", "AuthorId", "dbo.Authors");

DropIndex("dbo.Books", new[] { "AuthorId" });

DropTable("dbo.Books");

DropTable("dbo.Authors");

}

Right click on your project, select Add, then Add ASP.Net Folder and choose the App_Data folder

PM> Update-Database -Verbose

That is all! now we have our database working and you can explorer it , Next article will be in how to create ASP.NET RESTful APIs (web api) .

- link to project in github.

Getting Started - Create a simple Single Page Application (SPA) - Angularjs

2016-11-15T05:42:00.000-08:00

Create a Single-Page Application (SPA) - Angularjs
- This article is Part of a series :

Getting Started - Create a simple Single Page Application (SPA) - Angularjs

Getting Started - Entity Framework Code First

Getting Started - Web API

Getting Started - Create a SPA And use AngularJS $http Service

A single-page application (SPA) is a web application or web site that fits on a single web page with the goal of providing a user experience similar to that of a desktop application. (wikipedia).

- Create new html page named main or index

use ng-view In order to determine loading part (html template) , your main page will look like this :

//main.html

<!DOCTYPE html>

<head>

</head>

<body>

</div>

</body>

</html>

- add new folder named templates

- add 2 new pages to templates folder named books.html & authors.html

The books.html & authors.html are samples pages contain table of authors and table of books (we'll go through implementation later in this article)

- now we will configure our angularjs app to use routing

Add 3 JavaScript files in new folder (or script folder) named (myLibrary.js , booksController.js , authorsController.js ) .

Open myAppModule.js and write the following configuration :

//myLibrary.js

var myLibrary = angular.module("myLibrary", ['ngRoute'])

.config(function ($routeProvider) {

$routeProvider.when('/books', { templateUrl: '/templates/books.html', controller: 'booksController' });

$routeProvider.when('/authors', { templateUrl: '/templates/authors.html', controller: 'authorsController' });

//default

$routeProvider.otherwise({ templateUrl: '/templates/books.html', controller: 'booksController' });

});

Open booksController.js and create books array for $scope.books :

//booksController.js

myLibrary.controller("booksController", function ($scope) {

$scope.books = [

{ name: 'A brief history of time', author: 'Stephen Hawking' },

{ name: 'Death: The Final Stage of Growth', author: 'Elisabeth Kübler-Ross' },

{ name: '50 Mathematical Ideas You Really Need to Know', author: 'Tony Crilly' },

{ name: 'The Grand Design', author: 'Tony Crilly', author: 'Stephen Hawking'}

];

});

Same steps in authorsController.js :

//authorsController.js

myLibrary.controller("authorsController", function ($scope) {

$scope.authors = [

{ authorname: 'Stephen Hawking' , numOfBooks : 2 },

{ authorname: 'Elisabeth Kübler-Ross', numOfBooks: 1 },

{ authorname: 'Tony Crilly', numOfBooks: 1 }]

});

- Open books.html and create books table (I used bootstrap for styling) :

//LibraryDbContext.cs

<div>

<thead>

<tr>

<th>

Book Name

</th>

<th>

Author

</th>

</tr>

</thead>

<tr>

<td>

</td>

<td>

</td>

</tr>

</tbody>

</table>

</div>

To do authors.html(same steps).

- add scripts and links references to main.html :

//main.html

<!DOCTYPE html>

<head>

</head>

<body>

</button>

<a class="navbar-brand" href="#">Library</a>

</div>

<li><a href="#books">Books</a></li>

<li><a href="#authors">Author</a></li>

</ul>

</div>

</div>

</body>

</html>

main page

- That is it , Click here to get a copy from github.

Your First Angular App

2016-11-14T06:48:00.004-08:00

It's easy to use Angular , I think it's more easy and fun than jquery , so let's see a basic example .

To create basic Angular app you have to create a module then attached Controller to it, in your script you can define your module name and your controller like this :

//javascript.js file

angular.module('myApp', []).controller('myController', function ($scope) {

//write whatever code and functions herer

});

In your html page or in your main page refer to your module in <html> attrubite or <body> and refer to your controller in the section that you need to integrate with that controller like this :

//index.html

<head>

</head>

</body>

</html>

back to your script , use $scope as var , it may hold array or function :

//javascript.js file

angular.module('myApp', []).controller('myController', function ($scope) {

$scope.numbers = [1, 2, 3, 4];

$scope.alertnum = function (num) {

alert('you have clicked : ' + num)

};

});

Use ng-repeat to loop through $scope.numbers in Dom and ng-click to invoke $scope.alertnum like this :

//index.html

<head>

</head>

</a>

</div>

</body>

</html>

here is a working example

See the Pen Your First Angular App by Mohamed Salah (@saad306) on CodePen.

مثال بسيط علي انشاء WCF Service الجزء الثالث

2013-04-11T08:27:00.000-07:00

· انشاء WCF Client Application

- من Solution Explorer قم باضافة Project جديد من النوع Console Application باسم BirthdayClient

- من Solution Explorer قم باضافة مرجع Add Reference الي System.ServiceModel assembly الي BirthdayClient Project بالضغط بالزر الايمن للماوس عليه ثم اختيار Add Reference

- ايضا قم باضافة Service Reference بالضغط بالزر الايمن للماوس علي BirthdayClient ثم اختار Add Service Reference ومن الصفحة التي ستظهر قم بالضغط علي Discover ليقوم بالبحث عن الـ Service المتوفرة لتظهر لك Service التي انتهينا من انشائها قم بالضغط عليها وفي اسف الصفحة في مريع النص Name Space قم بتغير الاسم الي BirthdayService ثم قم بالضغط علي Ok كما بالشكل

- بالتوجه App.config في BirthdayClient وفتحه ليظهر الكود سوف تجد ان WCF Service قامت بعمل تهيئة الاتصال بالـ Service كما بالكود التالي

<?xml version="1.0" encoding="utf-8" ?>

</startup>

<system.serviceModel>

</basicHttpBinding>

</bindings>

<endpoint address="http://localhost:12516/Service.svc" binding="basicHttpBinding"

bindingConfiguration="BasicHttpBinding_IBirthdayService" contract="BirthdayService.IBirthdayService"

name="BasicHttpBinding_IBirthdayService" />

</client>

</system.serviceModel>

</configuration>

- ستجد في الجزء الخاص بالـ <client> تحديد طريقة الاتصال بـ Service في <endpoint> يوجد معلومات الاتصال وهي تتكوت من 3 اجزاء address , binding , contract

- الان قم بفتح Program.cs ثم قم باضافة المراجع الاتية

using System.ServiceModel;

using BirthdayClient.BirthdayService;

- في Main method قم بانشاء New Instance من BirthdayService ليصبح الكود كالاتي

static void Main(string[] args)

{

BirthdayServiceClient proxy = new BirthdayServiceClient();

}

- الان يمكنك استخدام Service Method التي انشائنها من قبل والاتي هو مثال استخدام ListFirstName() Method

static void Main(string[] args)

{

BirthdayServiceClient proxy = new BirthdayServiceClient();

Console.WriteLine("Now The Console will Write All First Name");

string[] info = proxy.ListFirstName();

foreach (string name in info)

{

Console.WriteLine(name);

}

proxy.Close();

Console.ReadKey();

}

- قبل ان تقوم باختبار الـ Client Project يجب عليك وضع الـ Startup Projects بالضغط علي الـ Sultion (BirthdayService) بالزر الايمن للماوس واختيار Set Startup Projects

- من الصفحة التي ستظهر قم باختيار Multiple startup projects وقم بتحديد الـ Projacts الاتية باختيار Start كما بالشكل

- بعد التحديد والضغط علي Ok قم بالضغط علي Ctrl + F5 للاختبار كما بالشكل

- الي هنا نكون قد انتهينا من هذا الجزء في الجزء القادم سوق اقوم بشرح كيف تقوم بعمل deploying للـ Service علي IIS (Internet Information Services)

مثال بسيط علي انشاء WCF Service الجزء الثاني

2013-04-11T08:10:00.000-07:00

بعد انشاء Entity Model الان سنقوم بانشاء WCF service

- من Solution Explorer قم بالضغط بالزر الايمن للماوس واختار Add >> New Web Site ومن الصفحة التي ستظهر قم باختيار WCF service

- باختيارك WCF Service Template سيتم انشاء WCf كـ جزء من Web Application في App_Code فولدر ستجد IService.cs Interface و ايضا Service.cs Class وبالنظر الي Service.cs سوف تجد ان WCF Service Template اضاف المراجع العادية واضاف المراجع التي سيتم استخدامها في WCF Service وهي System.ServiceModel , System.ServiceModel.Web , System.Runtime.Serialization كما بالشكل

- الـ System.ServiceModel تحتوي Classes التي ستستخدمها WCF لتحدد Service والعمليات وبالطبع فأن System.Runtime.Serialization تستخدم لتحويل Objects الي Stream Of Data لنقلها عن طريق Network والمعروفة باسم serialization وايضا تستخدم لعكس العملية بمعني تحويل Stream الي objects والمعروفة بأسم deserialization

- بالنظر الي الكود ستجد ان هناك 2 methods وهي GetData و GetDataUsingDataContract وقد تم ادراجاهم من IService Interface

- بفتح IService.cs من App_Code كما بالشكل الاتي والنظر الي الكود

ستجد ان Iservice تحتوي علي 2 methods والتي تم تنفذهم في Service.cs Class وهما GetData , GetDataUsingDataContract والمعروفين باسم service contract ويتم تعرفيهم عن طريق استخدام attributes كما بالشكل السابق وهما [ServiceContract] و [OperationContract] .

ايضا ستجد Class باسم CompositeType وهي Type Returned عن طريق GetDataUsingDataContract Method والتي تستخدم attributes [DataContract] و [DataMember] وهي عبارة مثال للـ data contract وساقوم بتوضيحها .

أ - انشاء interfaces او Contracts الخاصة بهذا المثال والتي سيتم تنفيذيها في Sevice.cs

· تحديد الـ Datacontarct

- قم بفتح IService.cs واحذف كل الكود ما عدا المراجع ( using statement )

- من Solution Explorer قم بتغير اسم IService.cs الي IBirthdayService.cs

- قم باضافة Name Space بأسم Birthday كالاتي

namespace Birthday

{

}

- قم بانشاء Class باسم Birthday وحدد بها الـ member المستخدمة في ال Entity Model

[DataContract]

public class BirthdayData

{

[DataMember]

public string FirstName;

[DataMember]

public string LastName;

[DataMember]

public DateTime birthdayDate;

}

- بوضع الـ attribute [DataContract] فاننا نحدد ان هذه الـ Class ستستخدم serialized و deserialized كـ XML Stream بواسطة WCF يمكنك استخدام [DataContract] attribute في classes, structures, enumerations

- يجب ان تضع [DataMember] attribute علي كل member في الـ Class اذا كنت تريد ان يتم عليه عملية serialized

· تحديد الـ service contract

- قم باضافة IBirthdayService interface بعد BirthdayData Class وحدد بها العمليات التي سيتم استخدامها كالاتي

[ServiceContract]

public interface IBirthdayService

{

//Return all FirstName

[OperationContract]

List<string> ListFirstName();

//Return FullData by FirstName

[OperationContract]

BirthdayData GetFullInfo(string firstName);

}

ب - تنفيذ Service

الان بعد تحديد serviceContract في IBirthdayService interface سنقوم بتنفيذ الـ mothod التي بها .

- قم باضافة مرجع الي BirthdayEntityModel project بالذهاب الي الـ Birthdayservice Projact في الـ Solution Explorer قم بالضغط بالزر الايمن للماوس ثم قم بالضغط علي Add Reference من القائمة علي الشمال اختار Projacts ثم قم باختيار Entity Model واضغط Ok كما ف الشكل

- قم باضافه مرجع الي System.Data.Entity بعمل نفس الخطوات السابقة في الاضافة ومن القائمة علي الشمال قم باختار Assemblis ومنها اختار framework ثم قم باستخدام مربع البحث علي اليمن كما بالشكل ثم قم بتعليم checkbox الذي سيظهر كما بالشكل

- بالذهاب App_Code فولدر قم بتسمية Service.cs الي BirthdayService.cs ثم قم بفتحها

- الان قم بحذف كل الكود ما عدا المراجع ( using statement )

- قم باضافة مرجع الي BirthdayModel باستخدام using BirthdayEntityModel;

- قم باضافة Birthday name space

namespace Birthday

{

}

- قم باضافة Class وقم بتسميتها BirthdayServiceImplement ثم قم بعمل inheritance للـ IBirthdayService كالاتي

namespace Birthday

{

public class BirthdayServiceImplement : IBirthdayService

{

}

- الان يمكنك تضمين الـ methods في IBirthdayService بالوقوف عليها والضغط بالزر الايمن للماوس ثم اختيار Implement Interface كما البشكل

- الان سوف نقوم باضافة الكود الي الـ method ListFirstName() ليكون كالاتي

public List<string> ListFirstName()

{

List<string> FirstNameList = new List<string>();

using (birthdaydbEntities db = new birthdaydbEntities())

{

var firstname = from birthday in db.BirthDays

select birthday.FirstName;
FirstNameList = firstname.ToList();

}

return FirstNameList;

}

- بعد اضافة الكود للـ method الاولي سنقوم باضافة الكود للـ method الثانية ليكون كالاتي

public BirthdayData GetFullInfo(string firstName)

{

BirthdayData birthdayData = null;

using (birthdaydbEntities db = new birthdaydbEntities())

{

BirthDay findInfo = db.BirthDays.First(b => string.Compare(b.FirstName, firstName) == 0);

birthdayData = new BirthdayData()

{

FirstName = findInfo.FirstName,

LastName = findInfo.LastName,

birthdayDate = findInfo.birthdayDate

};

}

return birthdayData;

}

· تهيئة WCF Service

الان يجب تيهئة Service وذلك بربطها بـ Birthday.cs الذي انتهينا منه في الخطوة السابقة

- بالذهاب الي Service.svc من Solution Explorer نقوم بالضغط عليها مرتين ليظهر لنا الكود الاتي

<%@ ServiceHost Language="C#" Debug="true" Service="Service" CodeBehind="~/App_Code/Service.cs" %>

- نقوم بتعديل الكود وتحديد اسم Service التي تم تغيرخ ليصبح الكود كالاتي

<%@ ServiceHost Language="C#" Debug="true" Service="Birthday.BirthdayServiceImplement" CodeBehind="~/App_Code/Birthday.cs" %>

- قم بالذهاب App.Config للـ BirthdayEntityModel وقم بنسخ النص الاتصال منه ومن المفترض ان يكون بهذا الشكل

</connectionStrings>

- الان قم بالذهاب الي WCf Service من الـ Solution Explorer ثم قن بفتح Web.config وقم باضافة نص الاتصال الذي قمت بنسخة في جزء <configuration> وقبل <system.web> ليكون الشكل النهائي للكود في Web.config كالاتي

<?xml version="1.0"?>

</appSettings>

</connectionStrings>

<system.web>

</assemblies>

</compilation>

</system.web>

<system.serviceModel>

</behavior>

</serviceBehaviors>

</behaviors>

</protocolMapping>

</system.serviceModel>

<system.webServer>

<!--

To browse web app root directory during debugging, set the value below to true.

Set to false before deployment to avoid disclosing web app folder information.

-->

</system.webServer>

</configuration>

- الان قم بحفظ Web.config ثم قم بالذهاب الي Service.svc وقم بالضغط عليها بالزر الايمن للماوس ثم قم باختيار View in Browser كما بالشكل

- سوف تظهر لك الـ help page للـ WCF Service للتأكد من تهيئة Service بشكل صحيح كما بالشكل الاتي

- الي هنا نكون انتهينا من الجزء الثاني في الجزء القادم ساقوم بانشاء Clint application .

مثال بسيط علي انشاء WCF Service الجزء الاول

2013-04-09T03:16:00.000-07:00

اولا : انشاء Entity Model التي سنقوم باستخدامها مع WCF Service

- قم بانشاء New Project من النوع Class Library وقم بتسميته BirthdayEntityModel وقم باعطاء Solution Name اسم BirthdayService كما بالشكل

- بعد انشاء الـ Project قم بحذف Class1 من الـ Solutions Explorer

- قم باضافة New Item بالضغط بالزر الايمن للماوس علي BirthdayEntityModel واختيار Add >> New Item واختيار ADO.Net Entity Data Model وفي خانة الاسم قم بكتابة الاسم BirthdayModel.edmx

- من Entity Data Model Wizard التي ستظهر فور اضافة الـ Model قم باختيار Generate From Database ومن Choose Your Data Connection قم بالضغط علي New Connection لتحديد مصدر البيانات كما بالشكل

- بعد انا تحدد مصدر البيانات والضغط علي Ok سيتم الرجوع الي الصفحة السابقة قم بعد ذلك بالضغط علي Next لتحديد الـ Objects التي تريد استخدامها كما بالشكل

- بعد الضغط علي Finish سيتم انشاء الـ Entity Model يحتوي علي الـ table التي تم تحديدها كما بالشكل الاتي

- قم بعمل Build Soultion بالضغط علي F6

الان قمنا باعداد الـ Entity Model التي سنقوم باستخدامها لارجاع البيانات من والي Database باستخدام WCF Service

الان يمكننا انشاء انشاء WCF Service

- ملحوظة

الـ table التي تم استخدامها ذكرت سابقأ في مثال علي اعداد تقارير Microsoft Report - Client-Side Reporting الجزء الاول

مثال علي اعداد تقارير Microsoft Report - Client-Side Reporting الجزء الثالث والاخير

2013-02-26T06:32:00.000-08:00

ثالثاً - عرض التقرير

- اعداد الـ Forms

الان بعد اعداد التقرير سنقوم باعداد عدد 2 Form , الـ Form الاولي سنضع بها 2 dateTimePicker وونعطيهم الاسماء dtFrom و dtTo علي الترتيب , وايضا نقوم بوضع button لياخذ الاسم btnShowReport ليكون الشكل كالاتي :

الـ Form الثانية ستستخدم لعرض التقرير نقوم بوضع reportViewer من الـ ToolBox ونقوم بالاعلان عن DataSet وفي Form Constructor نقوم بوضع Dataset كـ parameter ليصبح الكود في Form 2 كالتالي

using System.Data;

using System.Drawing;

using System.Linq;

using System.Text;

using System.Windows.Forms;

using Microsoft.Reporting.WinForms;

namespace WindowsFormsApplication1

{

public partial class Form2 : Form

{

DataSet DsReport = new DataSet();

public Form2(DataSet dsReport)

{

InitializeComponent();

DsReport = dsReport;

}

وشكل Form2 كالتالي

وبالعودة للـ Form الاولي وبعد اضافة الحدث btnShowReport_Click بالضغط مرتين علي زر العرض كما بالشكل الاول

يكون الكود كالتالي

using System;

using System.Data;

using System.Text;

using System.Windows.Forms;

using Microsoft.Reporting.WinForms;

using System.Data.SqlClient;

namespace WindowsFormsApplication1

{

public partial class Form1 : Form

{

public Form1()

{

InitializeComponent();

}

private void btnShowReport_Click(object sender, EventArgs e)

{

string connstring = @"Data Source=.\sqlexpress;Initial Catalog=birthdaydb;Integrated Security=True";

using (SqlConnection MyConn = new SqlConnection(connstring))

{

SqlCommand Command = new SqlCommand("Select * from FUBirthDayReport(@DtFrom , @DtTo)", MyConn);

Command.CommandType = CommandType.Text;

Command.Parameters.AddWithValue("@DtFrom", Convert.ToDateTime(dtFrom.Value));

Command.Parameters.AddWithValue("@DtTo", Convert.ToDateTime(dtTo.Value));

MyConn.Open();

SqlDataReader Reader = Command.ExecuteReader();

DataSet dsReport = new DataSet1();

dsReport.Tables[0].Load(Reader);

Reader.Close();

MyConn.Close();

Form2 frm2 = new Form2(dsReport);

frm2.ShowDialog();

}

وبالعودة الي Form2 لنقوم باكمال الكود النهائي كالتالي

public partial class Form2 : Form

{

DataSet DsReport = new DataSet();

public Form2(DataSet dsReport)

{

InitializeComponent();

DsReport = dsReport;

}

private void Form2_Load(object sender, EventArgs e)

{

reportViewer1.Reset();

reportViewer1.LocalReport.ReportEmbeddedResource =

"WindowsFormsApplication1.BirthDayReport.rdlc";

ReportDataSource rds = new ReportDataSource();

rds.Name = "DataSetBirthDay";

rds.Value = DsReport.Tables[0];

reportViewer1.LocalReport.DataSources.Add(rds);

reportViewer1.RefreshReport();

}

الان قد انتهينا من اعداد عرض التقرير ومن المفترض ان تكون النتيجة كما بالشكل :

ملحوظة : يجب الاهتمام بتنسيق التقرير ليصبح الشكل النهائي افضل من ذلك فالتقارير من اهم الاجزاء التي يجب الاهتمام بها عند تطويرك لاي برمجيات .

مثال علي اعداد تقارير Microsoft Report - Client-Side Reporting الجزء الثاني

2013-02-25T04:46:00.001-08:00

ثانيا - اعداد التقارير

- اولا التكوين او الهيكل : ينقسم الـReport الي ثلاث اجزاء هي

· الراس – Header

- وهو المكان الذي يوضع فيه العنواين والتورايخ واشياء اخرى مثل شعار الشركة وارقام التليفونات بمعني اخر يعتبر رأس التقرير هو تعريف التقرير وهو مهم جدا في اي تقرير .

· الجسم – Body

- وهو المكان الذي يوضع به تفاصيل التقرير مثل المعاملات التجارية بشكل موجز او مفصل والاجماليات

· الذيل او نهاية الصفحه – Footer

- يمكن ان يوضع في نهاية الصفحه معلومات مثل رقم الصفحه ومعلومات حقوق النشر ومعلومات اخري طبقا لرغبة المصمم او العميل

- ادوات التقرير - Report Tool Box

في الفقره الاتيه ساتطرق الي الادوات التي سيتم استخدامها في المثال :

· Table

- الـ Table هي من اهم الادوات التي يستخدمها المطورون في عملهم كما هو واضح من الاسم تستخدم الـ Table لعرض البيانات بطريقة رائعه تتكون الـ Table من

أ – الراس – Header : يستخدم في اظهار اسماء الـ Columns المستخدمة .

ب – التفاصيل - Detail : يستخدم لعرض البيانات في شكل صفوف بشكل ألي .

جـ - الذيل – Footer : يستخدم لانشاء ملخص او اجماليات .

· TextBox

- يمكن استخدام الـ Text Box لاضافه عنوان الريبورت او استخدامها في Page Header او Page Footer او في Body كما يمكن ايضا استخدمها كـ Data Field بمعني اخر غالبا ما تستخدم TextBox بشكل او باخر داخل الـ Report

الان بعد ملخص عن تكوين الـ Report نقوم باضافه Report جديد من Project Solution >> Add New Item

· Line

- يستخدم الـ Line للفصل بين البيانات وفي التنسيق بشكل عام

- ثانيا انشاء الـ Report

الان نقوم باضافه ريبور جديد من الـ

Project Solution >> Add >> New Item >> Report

بعد اضافه Report سنقوم باضافه Page Header و Page Footer

بالضغط بالزر الايمن للماوس علي الصفحه نقوم باختاير Page Header و Page Footer او يمكن اختيارها من Tool Box كما بالشكل

بعد تقسيم الصفحة يمكننا اضافه الادوات التي نريدها باستخدام Report Tools الان جاء دورك في اضافه الادوات لرأس وذيل التقرير كما تحب وقد قمت باضافه Textboxes باراقام التليفوانات وبيانات شركتي كما بالشكل

سوف تلاحظ اضافتي لـ Field مثل تاريخ الطباعه وعدد الصفحات في نهاية التقرير يمكنك اضافتها وبيانات اخري عن طريق

Report Data >> Built-in Fields يمكن اظهار Report Data من شريط القوائم بالضغط علي View واختيار الـ Report Data او عن طريق الضغط مباشرة علي CTRL + ALT + D

- بعد تصميم الراس والذيل سنقوم بتوصيل الـ Report بـ الـ DataSet التي قمنا تم انشأها في الجزء الاول , عن طريق الـ Report Data نقوم باختيار New ثم DataSet ليظهر مربع حوار نقوم بتسميه التي نريدها ونختار الـ Dataset المطلوبة

بعد الضغط علي OK سوف يظهر لك الـ Dataset بالحقول التي تم انشاءها في Rport Data

والتي يمكن سحبها وافلاتها في اي مكان في التقرير الان سوف اقوم بتصميم عنوان التقرير في منطقة الـ Report Body

والذي سيكون عنوانه كالتالي

تقرير تواريخ الميلاد خلال الفتره من DateFrom الي DatatTo

الان نقوم باضافه Table لعرض التقرير من Tool Box قم بسحب وافلات Table ومن Properties ومن الخاصية DataSetName نقوم باختيار الـ DatSet التي قمنا باضافتها الي الـ Report من قبل

بالضغط بالماوس علي Tablix يمكننا اضافة عدد الـ Columns التي نريد ان نقوم بعرضها وكما رأيت شكل الـ Table وتقسيمها عن المرور بالماوس علي الصف الثاني DataRow سيظهر لك مربع صغير بالضغط عليه يمكن اخنيار Field الدذي تريده كما الشكل

بعد الانتهاء من تسمية الحقول في راس الـ Tabel واضافه Data Field يمكنك ان تقوم يتنسيق الـ Tabel كما تريد انظر الشكل الاتي :

الي الان تم الانتهاء من الجزء الثاني لاعداد التقارير , في الجزء الثالث سأسرد طريقة عرض التقرير باستخدام الـ C#

مثال علي اعداد تقارير Microsoft Report - Client-Side Reporting الجزء الاول

2013-02-23T11:49:00.001-08:00

- اولا اعداد مصدر البيانات الـ Dataset

في هذا المثال سوف نستخدم Dataset كمصدر محلي للبيانات , يمكن ان نعيد البيانات الي Dataset من اي قاعده بيانات كـ SQL SERVER او Oracle او ....

وفي الفقرة القادمه ساسرد طريقة ارجاع البيانات للـ Dataset باستخدام SQL Server Table Valued Functions

1 -

من Project Solution ومن Add New Item نقوم باختيار Dataset من النافذة التي ستظهر .

بعد اضافه Dataset وباستخدام الـ Dataset Designer نقوم بضغط الزر الايمن للماوس واختيار

Add >> Data Table او يمكن افلاتها من ToolBoxكما بالشكل :

2- بعد اضافه الـ Data Table يمكننا اضافه الـ Columns وتسميتها كما نريد بالضغط علي الـ Data Table

Add >> Column , قمت باضافة الـ Columns وحددت نوع البيانات كالاتي:

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

- ثانيا اعداد مصدر البيانات من SQlServer

بعد انشاء قاعدة البيانات سنقوم بانشاء الــ Table التي سنستخدمها تحتوي علي Culomns الاتية

وهذا اسكريبت انشائها

-----------------------------------------------------------------------------------------------------------

/****** Object: Table [dbo].[BirthDay] Script Date: 02/23/2013 21:00:25 ******/

SET ANSI_NULLS ON

SET QUOTED_IDENTIFIER ON

CREATE TABLE [dbo].[BirthDay](

[Id] [int] IDENTITY(1,1) NOT NULL,

[FirstName] [nvarchar](50) NOT NULL,

[LastName] [nvarchar](50) NOT NULL,

[birthdayDate] [date] NOT NULL,

CONSTRAINT [PK_BirthDay] PRIMARY KEY CLUSTERED

(

[Id] ASC

)WITH (PAD_INDEX = OFF, STATISTICS_NORECOMPUTE = OFF, IGNORE_DUP_KEY = OFF, ALLOW_ROW_LOCKS = ON, ALLOW_PAGE_LOCKS = ON) ON [PRIMARY]

) ON [PRIMARY]

-----------------------------------------------------------------------------------------------------------

2 -

الان سنقوم بانشاء Table Function التي ستقوم بارجاع البيانات من الجدول خلال فتره معينة باستخدام 2 براميتر هما

يعبران عن بداية ونهاية الفترة كما في هذا السكريبت

-----------------------------------------------------------------------------------------------------------

/****** Object: UserDefinedFunction [dbo].[FUBirthDayReport] Script Date: 02/23/2013 21:06:07 ******/

SET ANSI_NULLS ON

SET QUOTED_IDENTIFIER ON

Create FUNCTION [dbo].[FUBirthDayReport](@DateFrom Datetime , @DateTo Datetime)

RETURNS @BirthDayOrder Table

(

Se int identity(1,1) ,

FullName nvarchar(110) ,

BirthDay Date ,

DateFrom datetime ,

DateTo datetime

)

Begin

declare @Crs Cursor ,

@FullName nvarchar(50) ,

@BirthDay Date;

Set @Crs = Cursor For Select FirstName + ' ' + LastName As FullName , birthdaydate

From BirthDay

Where birthdaydate Between @DateFrom And @DateTo

Order by birthdaydate , FullName

Open @Crs ;

Fetch next From @Crs

Into @FullName , @BirthDay ;

While(@@FETCH_STATUS = 0)

BEGIN

Insert into @BirthDayOrder

(FullName , BirthDay , DateFrom , DateTo)

values

(@FullName , @BirthDay , @DateFrom , @DateTo)

Fetch next From @Crs

Into @FullName , @BirthDay ;

End

Close @Crs

Deallocate @Crs

Return ;

End

------

- الان اصبحت مصادر البيانات جاهزة الجزء الثاني من هذا المقال سيتناول طريقة تصميم التقارير

التعامل مع DataGridView باستخدام C#

2013-02-22T07:32:00.000-08:00

افترض ان الـ DataGridView المستخدمه في الشرح التالي تتكون من اعمدة تأخد الاسامي Column1 و Column2 ..

1 – الانتقال الي خلية محددة - Move to specific Cell

- عن طريق تحديد رقم الخلية ورقم الصف

dataGridView1.CurrentCell =dataGridView1.Rows[0].Cells[1];

في الكود السابق تم الانتقال للخلية الثانية في الصف الاول من DataGridView

يمكن الاستعانه باسم العمود كالتالي

dataGridView1.CurrentCell =

dataGridView1.Rows[0].Cells[Column2.Index];

- وللانتقال للخلية في نفس الصف

dataGridView1.CurrentCell = dataGridView1.Rows[dataGridView1.CurrentRow.Index].Cells[Column4.Index];

- وللانتقال للخلية التاليه في نفس الصف

dataGridView1.CurrentCell =

dataGridView1.Rows[dataGridView1.CurrentRow.Index].Cells[dataGridView1.CurrentCell.ColumnIndex + 1];

ولتفادي الخروج عن عدد الخلايا - Out Of Range في الكود السابق

if (dataGridView1.CurrentCell.ColumnIndex != Column4.Index)

{

dataGridView1.Rows[dataGridView1.CurrentRow.Index]

.Cells[dataGridView1.CurrentCell.ColumnIndex + 1];

}

else

{

dataGridView1.Rows[dataGridView1.CurrentRow.Index].Cells[0];

}

---------------------------------------------------------------------------------------------------------------------------------

2 – معرفة قيمة خليه محدده - Value of specific Cell

- نفس الكود السابقة باضافه الخاصية .Value يعد تحديد موقع الخلية

string MyCellValue =(string)dataGridView1.Rows[dataGridView1.CurrentRow.Index].Cells[Column2.Index].Value;

---------------------------------------------------------------------------------------------------------------------------------

3 – استخدام foreach مع DataGridView

يمكن استخدام foreach من اجل معرفة قيمة كل الخلايا في عمود معين واستخدامها في مصفوفه او لارسالها الي قاعدة البيانات :

string[] array = new string[dataGridView1.Rows.Count - 1];

foreach (DataGridViewRow row in dataGridView1.Rows)

{

if (!row.IsNewRow)

{

array[row.Index] = (string)row.Cells[Column2.Index].Value;

MessageBox.Show(array[row.Index]);

}

فيجوال سي شارب VC# استخدام خاصية الاكمال التلقائي AutoComplete للـ ComboBox مع DataGridView واستدعاء البيانات من SQL Server db

2013-02-16T06:24:00.000-08:00

اولا تقوم بانشاء الاعمده بالضغط علي Edit Columans من DataGridView Tasks كما موضع بالشكل

ثم نقوم بالضغط علي Add من مربع الحوار الذي سيظهر امامك وكما موضح بالشكل التالي نقوم بكتابه اسم العمود واختيار النوع "Type" DataGridViewComboBoxColumn ثم نقوم بكتابه اسم العمود الذي سيظهر للمستخدم

بعد الضغط علي Add نقوم باختيار NoThing من الخاصية DisplayStyle في Column Properties كما هو موضح بالشكل التالي :

بعد الضغط علي Ok , من DatagridView Properties نقوم باضافه الحدث EditingControlShowin بالضغط عليه بالماوس ليقوم بنقلنا الي الكود

وسيكون شكل الـ Event المحتوي للكود كالتالي :

private void dataGridView1_EditingControlShowing(object sender, DataGridViewEditingControlShowingEventArgs e)

{

}

نقوم بالاعلان عن ComboBox قبل كتابه الكود وايضا استخدام المجال System.Data.SqlClient

ليكون شكل الكود في النهاية كالتالي :

----------------------------------------------------------------------------------------------------------------------------------------------------------------

using System;

using System.Data;

using System.Data.SqlClient;

ComboBox DataGridProductCombo;

private void dataGridView1_EditingControlShowing(object sender, DataGridViewEditingControlShowingEventArgs e)

{

if (dataGridView1.CurrentCell.ColumnIndex == ColProduct.Index)

{

using (SqlConnection MyConn = new SqlConnection(connString))

{

MyConn.Open();

DataSet Datset = new DataSet();

SqlDataAdapter Adapter = new SqlDataAdapter("if exists( Select ProName From Products) Select ProName From Products else select Null as ProName", MyConn);

Adapter.Fill(DatSet, "Products");

MyConn.Close();

}

DataGridProductCombo = (ComboBox)e.Control;

DataGridProductCombo.DropDownStyle = ComboBoxStyle.DropDown;

DataGridProductCombo.AutoCompleteMode = AutoCompleteMode.SuggestAppend;

DataGridProductCombo.AutoCompleteSource = AutoCompleteSource.ListItems;

DataGridProductCombo.DataSource = DatSet.Tables["Products"];

DataGridProductCombo.ValueMember = "ProName";

DataGridProductCombo.DisplayMember = "ProName";

}

------------------------------------------------------------------------------------------------------------------------------------------------------------------

نقوم باضافه الحدث CellValidating بنفس طريقة اضافه الحدث السابق EditingControlShowing

ثم نقوم بكتابه الكود ليكون كالتالي

-------------------------------------------------------------------------------------------------------------------------------------------------------------------

private void dataGridView1_CellValidating(object sender, DataGridViewCellValidatingEventArgs e)

{

if (e.ColumnIndex == ColProduct.DisplayIndex)

{

if (!ColProduct.Items.Contains(e.FormattedValue))

{

ColProduct.Items.Add(e.FormattedValue);

}

----------------------------------------------------------------------------------------------------------------------------------------------------------------

من المفترض ان تكون النتيجة كما بالشكل ادناه

مثال علي تحليل وتصميم النظام Analysis and Design System

2012-07-03T05:37:00.005-07:00

قبل البدء ستجد في هذا الرابط مقدمه مختصره عن شرح النظام المستخدم .

مقدمة

مع تطور نظم أداره قواعد البيانات كان لابد من وجود آداه جيده لاستغلال الإمكانيات المتاحة في بيئة العمل التي تشتمل على هذه النظم وكانت المشكلة كيفيه ببن هذه النظم بطريقه علميه صحيحة حيث لتوجد طريقه صحيحة منظمه فكان الحاجة إلى تطوير البرمجيات وطريقه تطبيق وسهوله التعديل والصيانة فكانت تحليل النظام هي تلك الأداء التي وفرت كل هذه الطرق لقيام نظام ناجح يمكن الاعتماد عليه حيث إن عمليه التحليل لاى نظام تتطلب الفهم الصحيح للنظام من حيث المشاكل والبيانات والعمليات التي تتعامل مع هذه البيانات وفى هذه المرحلة من التحليل يتم تحديد وتعريف العمل الذي يحدث داخل المنظمة .

مفهوم.النظام (system):
عبارة عن مجموعة من العناصر مترابطة ومتحدة مع بعضها البعض لتحقيق هذف معين أو عبارة عن مجموعة من المدخلات التي يتم عليها عمليات حسابية ومنطقية لحصول على المخرجات المطلوبة.

اجزاء النظام:-
هي (المدخلات،المخرجات،نقاط،التشغيل) الدوال.

المدخلات الأساسية:-
هي المدخلات التي تدخل على النظام ويتم عليها عمليات تتحول إلى مخرجات وليس بالضرورة أن تدخل هذة المخرجات على هيئة مدخلات مرة أخرى. مثل: طلاب الجامعة.

المدخلات الاستبدالية:
وهي المدخلات التي تدخل إلى النظام وتصبح جزءً منها ولا يتم عليها عمليات تشغيلية ولا تتحول إلى مخرجات. مثل: المعدات والأجهزة.

المدخلات البيئية:
وهي التي تؤثر تأثيراً خارجياً على النظام ولا يتم عليها عمليات تشغيل وتصبح جزءً من أجزاء النظام ولا تتحول إلى مخرجات. مثل: الحرارة, المناخ, الطقس.

أنواع المخرجات:

1- مخرجات نهائية: وهي المخرجات التي تخرج نهائياً من النظام. مثل: خريجي الجامعات
2- المخرجات الارتدادية: وهي التي ترد إلى نفس النظام على هيئة مدخلات. مثال: المنتج الغير مطابق للمواصفات الاستهلاكية.

دورة تطوير"بناء" البرمجيات
وهي " تقنية " تستخدم لتطوير وبناء النظم البرمجية والتطبيقات المختلفة وتحقق الكفاءة وسهولة التعديل والصيانة لنظم المعلومات

خطوات تحليل النظم : تنقسم إلى

1- تحليل متطلبات النظام

2- تجميع البيانات وتحليلها

3- تنظيم البيانات وتوثيقها

4- توصيف التصميم المنطقي

1) تحليل متطلبات النظام :

وهى عمليه تحديد وفهم طبيعة المشكلة الموجودة في المؤسسة أو الهيئة التي سيتم تحليل النظام لها وتقديم المقترحات لحلها ، ومن هنا نجد إن طبيعة هذا النظام تحتاج إلى دراسة المشاكل المحيطة بهذا النظام القائم والتي تتلخص في :

1- البطء وعدم السرعة في استرجاع البيانات

2- عدم دقه البيانات المخزونة وذلك من طريقه تخزينها

3- صعوبة التعديل وأضافه البيانات الجديدة

4- صعوبة الصيانة الدورية للبيانات

5- الحجم الكبير للملفات الاساسيه للبيانات في الهيئات المختلفة

2) تجميع البيانات وتحليلها :

وهناك عده أساليب مختلفة في جمع المعلومات عن المشكلة ومنها :

أ‌- مقابله المسؤلين عن النظام المراد تنفيذه

ب‌- المقابلات الشخصية والاستبيانات

* المقابلات الشخصية :

وقد تمت أكثر من مقابله مع عدد من المسؤلين والذين يحتاجون إلى هذا النظام ومنهم :

وقد تم خلال المقابلات الاستفسار عن مجموعه من الاسئله مثل :

أولا : الاسئله المحددة

1- هل النظام الحالي جيد آم لا ؟

2- هل تريد استخدام الحاسبات بدلا من الطرق اليدوية ؟

3- هل النظام الحالي يوفر السرعة والسرية للمعلومات المخزونة ؟

4- هل تفضل أن يكون النظام الجديد يستخدم قواعد البيانات ؟

ثانيا الاسئلة الغير محددة الاجابات :

1- ماذا تريد من النظام الجديد .

2- ما هي العيوب التي تواجهك في النظام الحالي .

3- هل لديك اقتراح يمكن أن ننفذها لك في هذا النظام الذي سيتم إنشاؤه .

وبعد الاجابة علي الاسئلة السابقة بدأت تتضح لنا الخطوط الرئيسية لانشاء النظام الجديد .

3 – أدوات تحليل النظام

1- رسم تخطيطي لتدفق البيانات ( data flow diagram )

2- قاموس البيانات ( data dictionary )

3- رسم تخطيطي لبيئة البيابات ( data structure diagrams )

4- اللغة الانجليزية المنظمة ( structure English )

بناء رسم تخطيطي لبنية البيانات context diagram

عبارة عن رسم تخطيطي يوضح علاقة نظام البرامج الذي نرغب في تطويره بالمؤسسة أو الادارة التي يتم تطوير النظام لها . ويوضح الــ context diagram الاتي :

v تدقق البيانات من والي النظام

v كل مصادر البيانات ( source ) ومصبات البيانات ( sinks )

حيث أن :- المصدر هو الذي يعطي بيانات للنظام . والمصب الذي يأخذ بيانات من النظام .

يتم رسم ال context diagram اولا ثم بعد ذلك نقوم برسم الـــ DFD

الرسم التخطيطي لتدفق البيانات ( DFD )

وتستخدم هذه الاداة لوصف سريان المعلومات ونقط معالجة البيانات في النظام باستخدام الرسومات حيث من الرسم التخطيطي نستطيع أن نبين ذلك

( أ ) كيف يكون تدفق البيانات في النظام

( ب ) أين يتم معالجة البيانات في النظام

( ج ) اين يتم تخزين البيانات في النظام

تعريف ال DFD :

اختصار ل Data Flow Diagram اى الرسم التوضيحي لتدفق البيانات وهو رسم قياسي اى انه لغة موحده على مستوى واسع ويوضح كيفية تدفق البيانات والمستندات بالمنشاة ويتكون من مجموعه من الرموز التي يدل كل رمز منها على مكون ما

كيف يتم رسم DFD؟

يتم رسم ال DFD بناء على فهم كيفية سير العمل فى المنشاة و المستندات المختلفة المستخدمة بالمنشاة

ويوضح التالي:

1- من أين تأتي البيانات

2- كيف يتم التدفق

3-العمليات المنجزة على هذه البيانات

4- أين تذهب هذه البيانات

الفرق بين DFD وبين ERD

- أن ERD تمثل البيانات
-اما DFD تمثل العمليات اكثر

وفيما يلي شكل توضيحي للــــــــــ DFD الخاص بسير النظام:-

DFD - اضغط للتكبير

نموذج علاقة الكيانات(Entity Relationship Model)

تعريف نموذج علاقة الكيانات:

نموذج علاقة الكيانات (Entity Relationship Model)هو أحد الأساليب الشائعة لوضع تصور لقاعدة البيانات العلاقية وهو يعتمد على:

· تقسيم النظام إلى ما يسمى كيانات (مثل كيان موظف وكيان قسم في نظام شركة).

· كل كيان يحتوى على خصائص معينة تصفه وتحدده )مثل الاسم و العنوان ..الخ لكيان موظف).

· تحديد العلاقات بين هذه الكيانات وتوصيف خصائص هذه العلاقات كما سيتضح فيما بعد.

· تمثيل ذلك من خلال رسم يعبر عنه يسمى مخطط علاقة الكيانات.

أهمية نموذج مخطط) علاقة الكيانات(:

هو خطوة سابقة على تنفيذ قاعدة البيانات بأحد برامج نظم إدارة قواعد البيانات العلاقية

(RDBMS Relational Data Base Management System) وهو يساعد في عمل جداول أوملفات قاعدة
البيانات والعلاقات بينها على أسس علمية و صحيحة.

تلخيص لأهم الرموز المستخدمة في رسم الـ ERD

وفيما يلى شكل توضيحى للـ ERD الخاص بسير النظام :

ERD - اضغط للتكبير

Information Systems

Boosting Your Web App's Interactivity with Asp.Net Core 7 SignalR

Boosting Your Web App's Interactivity with Asp.Net Core 7 SignalR

Benefits of using SignalR for web app interactivity

Real-time updates and notifications

Chat functionality

Improved user engagement

How SignalR works

Setting up SignalR in your Asp.Net Core 7 project

Implementing real-time communication with SignalR

SignalR hub and client-side code

Broadcasting messages with SignalR

Scaling your SignalR application

Debugging and troubleshooting SignalR issues

Best practices for SignalR development

Conclusion

Simplify Your Data Synchronization Process with Dapper and Bulk Insert in ASP.NET

10 Tips for debugging .NET applications with SQL Server

A Beginner's Guide to Building RESTful APIs with .NET Core and SQL Server

Recursive algorithms

Recursion

Recursive function

A Recursive function is a function that calls itself ether directly or indirectly through another function .A Recursive function is called to solve a problem by solving a smaller instance of the same problem unless it is the simplest case(s) or so-called base case(s) it will return the result.

Example Computing Powers

Algorithm - Insertion Sort

JavaScript Prototypes and Inheritance

JavaScript Properties

Objects in JavaScript

Objects in JavaScript

Sort unordered list by JavaScript Array sort() Method

Use JavaScript sort() Method

How to Manipulate and fill HTML Table - JavaScript & jQuery

Manipulate and fill HTML Table

1- Fill table by using jQuery append method.

2- Fill table by retrieving data from user input .

Getting Started - Create a SPA And use AngularJS $http Service

AngularJS & Web API - SPA & $http

- This article is Part of a series :

Add new folder in Scripts folder named LibraryApp and add 4 JavaScript files named libraryModule.js , libraryService.js , booksController.js , authorsController.js) .

Getting Started - Web API

ASP.NET Web API

- This article is Part of a series :

Getting Started - Entity Framework Code First

Entity Framework Code First

- This article is Part of a series :

- Create the Data Model

- Create the Database Context

Getting Started - Create a simple Single Page Application (SPA) - Angularjs

Create a Single-Page Application (SPA) - Angularjs - This article is Part of a series : Getting Started - Create a simple Single Page Application (SPA) - Angularjs Getting Started - Entity Framework Code First Getting Started - Web API Getting Started - Create a SPA And use AngularJS $http Service

Create a Single-Page Application (SPA) - Angularjs

Add 3 JavaScript files in new folder (or script folder) named (myLibrary.js , booksController.js , authorsController.js ) . Open myAppModule.js and write the following configuration :

- That is it , Click here to get a copy from github.

Your First Angular App

مثال بسيط علي انشاء WCF Service الجزء الثالث

مثال بسيط علي انشاء WCF Service الجزء الثاني

مثال بسيط علي انشاء WCF Service الجزء الاول

مثال علي اعداد تقارير Microsoft Report - Client-Side Reporting الجزء الثالث والاخير

مثال علي اعداد تقارير Microsoft Report - Client-Side Reporting الجزء الثاني

مثال علي اعداد تقارير Microsoft Report - Client-Side Reporting الجزء الاول

التعامل مع DataGridView باستخدام C#

فيجوال سي شارب VC# استخدام خاصية الاكمال التلقائي AutoComplete للـ ComboBox مع DataGridView واستدعاء البيانات من SQL Server db

مثال علي تحليل وتصميم النظام Analysis and Design System

Add 3 JavaScript files in new folder (or script folder) named (myLibrary.js , booksController.js , authorsController.js ) .

Open myAppModule.js and write the following configuration :