- A community of 1% top performing developers and IT engineers

EnginR.co

Using Python to Save a Dataframe into Oracle Database You can use the library in combination with the and libraries to save a dataframe to an Oracle database in Python. pandas sqlalchemy cx_Oracle import pandas as pd
from sqlalchemy import create_engine
import cx_Oracle

# Create an SQLAlchemy engine using the connection
engine = create_engine('oracle://username:password@hostname:port/service_name')

# Save the dataframe to the Oracle database and lowercase your_table_name 
df.to_sql('your_table_name', con=engine, if_exists='replace', index=False) Replace , , , , and with your actual Oracle database credentials and connection details. 'username' 'password' 'hostname' 'port' 'service_name' Please replace with the actual lowercase name of the table in your Oracle database. Otherwise, you may encounter . your_table_name InvalidRequestError: Could not reflect: requested table(s) not available in Engine When you run this script, it will establish a connection to the database, create a sample dataframe, and then save the dataframe to the specified table in the Oracle database. Oracle Make sure the table structure has been created in the database before proceeding. Option 1: Create Table Structure using SQL Keep in mind that you will need to create the table structure in the Oracle database before attempting to save the dataframe to it. The table structure should match the structure of the dataframe in terms of column names and data types. You can create the table structure in your Oracle database using SQL. Here's an example of how you might create a table in Oracle to match the structure of your dataframe: CREATE TABLE your_table_name (
    column1_name  column1_data_type,
    column2_name  column2_data_type,
    ...
); Option 2: Create Table Structure using Python You can run the SQL script in Python using the method provided by the SQLAlchemy library. Here's an example of how you can execute an SQL script after creating the engine: engine.execute() from sqlalchemy import create_engine

# Create an engine
engine = create_engine('oracle://username:password@hostname:port/database_name')

# SQL script to create a table
sql_script =
CREATE TABLE your_table_name (
    column1_name  column1_data_type,
    column2_name  column2_data_type,
    ...
);

# Execute the SQL script
with engine.connect() as connection:
    connection.execute(sql_script) Make sure to replace , , , etc., with your actual table and column names and data types. your_table_name column1_name column1_data_type Conclusion Once the table structure is in place, you can then use the method I mentioned earlier to save the dataframe to the Oracle database. The method will automatically insert the data from the dataframe into the existing table in the database as long as the column names and data types match. to_sql Thank you for taking the time to explore data-related insights with me. I appreciate your engagement. If you find this information helpful, I invite you to follow me or connect with me on . Happy exploring!👋 LinkedIn

Saving Dataframes into Oracle Database with Python

As part of my love letter to Python, I decided to write a simple app, to be delivered little by little, showing common concerns you would find and possible solutions you could use when writing a Python “app”. I selected a simple to-do list app because it’s a simple and common problem. I decided to start with the data access layer because I’ve recently been working with . My previous experience was full of JDBC, Hibernate, MyBatis, JPA and Spring Data, and plain drivers using NodeJS. SQLAlchemy If you ever used an , you already know that it can save a lot of time, especially when starting a project, but as the codebase grows -if it’s used indiscriminately- you can end up with an impossible-to-tune-and-maintain application. So, I decided to use over this time. ORM SQLAlchemy Core ORM You can find the codebase . I always try to follow a TDD approach, so every implementation is accompanied by its corresponding set of tests. here The actual implementation has the following components: . Defines the database schema and provides connections wrapped in a Transaction Manager that keeps the database conversational state. Schema . It’s an abstract that implements the main 4 operations of a simple CRUD. Assuming that every table uses an auto-increment id field. BaseRepo repository and . Extends BaseRepo for Users. UserRepo tests and . Extends BaseRepo for To-dos. TodoRepo tests I have added -on purpose- a relationship between Users and To-dos for testing foreign constraints. Remember that this is — kind of — a PoC from a developer that has seen more Java and JavaScript code than Python. Schema About the implementation: Uses an env variable for creating the engine Defines the DB schema Offers methods to create and drop the DB schema Offers a Context Manager (TransactionManager) that wraps the connection and handles the DB conversational state. Easy to use with Python . with statements os sqlalchemy (
    create_engine, 
    Boolean,
    Column, 
    ForeignKey,
    Integer, 
    MetaData, 
    String,
    Table
) self.engine = create_engine(os.getenv( ), echo= , future= )
        self.metadata = MetaData()
        self.tables = self.__generate_tables() TransactionManager(self) self.metadata.create_all(self.engine) self.metadata.drop_all(self.engine) { : Table( , self.metadata,
                Column( , Integer, primary_key= , autoincrement= ),
                Column( , Integer, ForeignKey( )),
                Column( , String( )),
                Column( , Boolean)
            ), : Table( , self.metadata,
                Column( , Integer, primary_key= , autoincrement= ),
                Column( , String( )),
                Column( , String( ))
            ),
        } self.schema = schema
        self.conn = self.schema.engine.connect() self self.conn.commit()
        self.conn.close() import from import : class Schema : def __init__ (self) "DB_URI" True True : def create_transaction (self) return : def create_all_tables (self) : def drop_all_tables (self) : def __generate_tables (self) return 'todo' 'todo' 'id' True True 'user_id' 'user.id' 'description' 500 'active' 'user' 'user' 'id' True True 'email' 50 'fullname' 50 : class TransactionManager : def __init__ (self, schema) : def __enter__ (self) return : def __exit__ (self, type, value, traceback) BaseRepo About the implementation: Assumes that the table is defined in the schema and has an auto-increment id field. Separates insert from update. You could implement just a save operation, similar to an upsert. Returns cursors when finding all, not an array. Useful when handling several rows. abc ABC, abstractmethod sqlalchemy insert, select, update sqlalchemy.exc InvalidRequestError self.conn = tx.conn
        self.schema = tx.schema stmt = select(self._get_table()) self.conn.execute(stmt) table = self._get_table()
        stmt = select(table).where(table.c.id == id)
        res = self.conn.execute(stmt) res: res.fetchone() table = self._get_table()
        stmt = insert(table).values(user)
        res = self.conn.execute(stmt) res.inserted_primary_key[ ] prev_user = self.find_by_id(user[ ]) prev_user: InvalidRequestError( )
        stmt = update(self._get_table()).values(user)
        self.conn.execute(stmt) from import from import from import : class BaseRepo (ABC) : def __init__ (self, tx) : def find_all (self) return : def find_by_id (self, id) if return : def insert (self, user) return 0 : def update (self, user) 'id' if not raise 'Invalid id' @abstractmethod : def _get_table (self) pass TodoRepo About the implementation: Extends BaseRepo. Implements the only required method that returns the corresponding table from the Schema. Any specific data access methods should be implemented here. base_repo BaseRepo self.schema.tables[ ] from import : class TodoRepo (BaseRepo) : def _get_table (self) return 'todo' TodoRepoTest About the implementation: Uses in-memory sqlite DB, injected via env variables. Groups in classes tests per each method in TodoRepo. Creates a new schema per test. Enables foreign constraints. pytest sqlalchemy event, insert, select sqlalchemy.exc IntegrityError, InvalidRequestError schema Schema todo_repo TodoRepo monkeypatch.setenv( , )
    schema = Schema()
    _enable_foreign_constraints(schema)
    schema.create_all_tables() schema dbapi_con.execute( )
    event.listen(schema.engine, , _fk_pragma_on_connect) schema.create_transaction() tx:
            insert_obj(tx, , { : , : , : })
            insert_obj(tx, , { : , : , : , : })
            insert_obj(tx, , { : , : , : , : })
            todos = TodoRepo(tx).find_all().fetchall() len(todos) == todos[ ][ ] == todos[ ][ ] == todos[ ][ ] == todos[ ][ ] == todos[ ][ ] == todos[ ][ ] == todos[ ][ ] == todos[ ][ ] == schema.create_transaction() tx:
            todos = TodoRepo(tx).find_all().fetchall() len(todos) == schema.create_transaction() tx:
            insert_obj(tx, , { : , : , : })
            insert_obj(tx, , { : , : , : , : })
            insert_obj(tx, , { : , : , : , : })
            todo = TodoRepo(tx).find_by_id( ) todo[ ] == todo[ ] == todo[ ] == todo[ ] == schema.create_transaction() tx:
            todo = TodoRepo(tx).find_by_id( ) todo schema.create_transaction() tx:
            insert_obj(tx, , { : , : , : })
            id = TodoRepo(tx).insert({ : , : , : })
            table = tx.schema.tables[ ]
            todos = tx.conn.execute(select(table)).fetchall() len(todos) == todos[ ][ ] == id todos[ ][ ] == todos[ ][ ] == todos[ ][ ] == schema.create_transaction() tx:
            insert_obj(tx, , { : , : , : })
            TodoRepo(tx).insert({ : , : , : , : })
            table = tx.schema.tables[ ]
            todos = tx.conn.execute(select(table)).fetchall() len(todos) == todos[ ][ ] == todos[ ][ ] == todos[ ][ ] == todos[ ][ ] == schema.create_transaction() tx, pytest.raises(IntegrityError):
            insert_obj(tx, , { : , : , : })
            TodoRepo(tx).insert({ : , : , : , : }) schema.create_transaction() tx, pytest.raises(IntegrityError):
            TodoRepo(tx).insert({ : , : , : , : }) schema.create_transaction() tx, pytest.raises(IntegrityError):
            repo = TodoRepo(tx)
            repo.insert({ : , : , : , : })
            repo.insert({ : , : , : , : }) schema.create_transaction() tx:
            insert_obj(tx, , { : , : , : })
            insert_obj(tx, , { : , : , : })
            insert_obj(tx, , { : , : , : , : })
            TodoRepo(tx).update({ : , : , : , : })
            table = tx.schema.tables[ ]
            todos = tx.conn.execute(select(table)).fetchall() len(todos) == todos[ ][ ] == todos[ ][ ] == todos[ ][ ] == todos[ ][ ] == schema.create_transaction() tx, pytest.raises(InvalidRequestError):
            TodoRepo(tx).update({ : , : , : , : }) table = tx.schema.tables[table_name]
    stmt = insert(table).values(obj)
    tx.conn.execute(stmt) import from import from import from import from import @pytest.fixture : def schema (monkeypatch) "DB_URI" "sqlite://" return : def _enable_foreign_constraints (schema) : def _fk_pragma_on_connect (dbapi_con, con_record) 'pragma foreign_keys=ON' 'connect' : class TestTodoRepo_find_all : def test_when_multiple_todos (self, schema) with as 'user' 'id' 1 'email' 'a@test.com' 'fullname' 'fullname a' 'todo' 'id' 1 'user_id' 1 'description' 'description a' 'active' True 'todo' 'id' 2 'user_id' 1 'description' 'description b' 'active' False assert 2 assert 0 'id' 1 assert 0 'user_id' 1 assert 0 'description' 'description a' assert 0 'active' True assert 1 'id' 2 assert 1 'user_id' 1 assert 1 'description' 'description b' assert 1 'active' False : def test_when_empty (self, schema) with as assert 0 : class TestTodoRepo_find_by_id : def test_when_todo_exists (self, schema) with as 'user' 'id' 1 'email' 'a@test.com' 'fullname' 'fullname a' 'todo' 'id' 1 'user_id' 1 'description' 'description a' 'active' True 'todo' 'id' 2 'user_id' 1 'description' 'description b' 'active' False 1 assert 'id' 1 assert 'user_id' 1 assert 'description' 'description a' assert 'active' True : def test_when_todo_does_not_exists (self, schema) with as 1 assert is None : class TestTodoRepo_insert : def test_when_auto_increment_id (self, schema) with as 'user' 'id' 1 'email' 'a@test.com' 'fullname' 'fullname a' 'user_id' 1 'description' 'description a' 'active' True 'todo' assert 1 assert 0 'id' assert 0 'user_id' 1 assert 0 'description' 'description a' assert 0 'active' True : def test_when_set_id (self, schema) with as 'user' 'id' 1 'email' 'a@test.com' 'fullname' 'fullname a' 'id' 99 'user_id' 1 'description' 'description a' 'active' True 'todo' assert 1 assert 0 'id' 99 assert 0 'user_id' 1 assert 0 'description' 'description a' assert 0 'active' True : def test_when_invalid_id (self, schema) with as 'user' 'id' 1 'email' 'a@test.com' 'fullname' 'fullname a' 'id' 'invalid' 'user_id' 1 'description' 'description a' 'active' True : def test_when_invalid_user_id (self, schema) with as 'id' 1 'user_id' 1 'description' 'description a' 'active' True : def test_when_duplicated_id (self, schema) with as 'id' 1 'user_id' 1 'description' 'description a' 'active' True 'id' 1 'user_id' 1 'description' 'description a' 'active' True : class TestTodoRepo_update : def test_when_todo_exists (self, schema) with as 'user' 'id' 1 'email' 'a@test.com' 'fullname' 'fullname a' 'user' 'id' 2 'email' 'b@test.com' 'fullname' 'fullname b' 'todo' 'id' 1 'user_id' 1 'description' 'description a' 'active' True 'id' 1 'user_id' 2 'description' 'description b' 'active' False 'todo' assert 1 assert 0 'id' 1 assert 0 'user_id' 2 assert 0 'description' 'description b' assert 0 'active' False : def test_when_todo_does_not_exists (self, schema) with as 'id' 1 'user_id' 1 'description' 'description b' 'active' False : def insert_obj (tx, table_name, obj) Final words Definitively, SQLAlchemy is super powerful and simple at the same time! Really impressed by how easy it was to write these simple repos. The Java developer inside me says: change this and use objects! Maybe next time I’ll try the ORM implementation. However, my JavaScript developer side says: hell yeah! Forget about classes and open yourself to dictionaries. I don’t have a strong opinion, but I do know that you can write the same horrible app with and without classes. Still not sure about the performance of SQLAlchemy, what I read out there is that it’s pretty decent. Again, it’s going to significantly change depending on the queries you write! Hope you find useful this post. My plan is to continue expanding this project to address different concerns and possible solutions. Thanks for reading!

Building a To-do List App with Python: Data Access Layer with SQLAlchemy

How to Train Self-Parking Car Using Genetic Algorithm (<500 Lines of Code)

How to Build a Powerful Status Page With Great Performance and Design

The shutdowns brought an opportunity for my daughter to participate in virtual scouting events all over the United States. When the event registration form changed, I took the chance to try out some new web scraping skills while inspiring my daughter about the power of code for everyday tasks. My daughter is typically very involved in her local Girl Scout council. She has been a camp counselor and leader of events for younger girls. She goes the extra mile to earn badges and patches that expose her to new skills and activities. She is currently working on the highest award a Girl Scout can earn, the Gold Award. With the COVID shutdown, many of her local opportunities dried up, so she took the chance to explore activities at other councils offering virtual sessions. As just a sample: She learned to compose electronic music using javascript with a Florida council. During election season, she did a Rock the Vote workshop with a council in Washington State. And she earned her last two cybersecurity badges from some delightful leaders in Iowa. There's a lot of talent being shared out there in the councils. Recently, our council changed the registration form, so I can't  search for activities outside a 90 mile radius. When I asked the help desk, they advised entering different ZIP codes. In the Girl Scout spirit of "using resources wisely" -- where the resource is my time -- I knew there was a code-based solution that would work better than manually entering a lot of ZIP codes. I also had in the back of my mind to show my daughter an example of web scraping, since she has thought about using these techniques in creating some community resources for her Gold Award... taking the chance to build up that STEM pillar. First, I inspected the form fields using the browser DOM inspector and found that most of our favorite councils used the same object names. This solution uses Selenium, Beautiful Soup, pandas, and pangres, plus a handful of other small libraries. # libraries selenium webdriver selenium.webdriver.chrome.options Options bs4 BeautifulSoup pandas pd sqlite3 urllib.parse urlparse hashlib datetime datetime pangres upsert sqlalchemy create_engine import from import from import from import import as import from import import from import from import from import I also used a webdriver to automate the form submission. # retrieve and parse html 

options = Options()
# options.headless = True
options.add_argument( )

# webdriver Chrome
DRIVER_PATH = driver = webdriver.Chrome(options=options, executable_path=DRIVER_PATH) "--window-size=1920,1200" for '/Applications/chromedriver' I gathered a list of some of our favorite council form URLs. # add urls to list here needed; some our favorite councils virtual events
urls = [ \ , \ ,  \ ,  \ ,  \
        ] as of for "https://www.nccoastalpines.org/en/activities/activity-list.advanced.html" "https://www.girlscoutstoday.org/en/events/event-list.advanced.html" "https://www.girlscoutsww.org/en/events/event-list.advanced.html" "https://www.citrus-gs.org/en/events/event-list.advanced.html" Information would be stored in lists, so I set those up first. # initiate list buckets
links = []
titles = []
startdates = []
enddates = []
councils = []
uniquekeys = [] Going through a loop of each URL, I used the webdriver to submit the forms and collect the page sources. url urls:

        # click and submit
        driver.get(url)
        # driver.find_element_by_id( ).click()
        # driver.find_element_by_xpath( ).click()   
        driver.find_element_by_xpath( ).click()   
        driver.find_element_by_id( ).submit()

        # here is the page, make the soup
        page_source = driver.page_source
        soup = BeautifulSoup(page_source, )

        # get council identifier url
        council = urlparse(url).netloc.split( )[ ]
        primarylink = urlparse(url).netloc for in "sf-activities:program-level/seniors" "//input[contains(@id, 'program-level/senior')]" "//input[contains(translate(@id, 'ABCDEFGHIJKLMNOPQRSTUVWXYZ', 'abcdefghijklmnopqrstuvwxyz'), 'program-level/senior')]" "sub" 'lxml' from "." 1 Then, still in the loop, I could parse the resulting html with Beautiful Soup. I also added a hashed unique id in place of the default ID, and parsed the council identifier out of the url. # now get the data on each page x soup.find_all(class_= ):

            link = title = startdate = enddate = link = primarylink + x.h6.a[ ]
            links.append(link)

            title = x.h6.a.text
            titles.append(title)

            startdate = x.find_next( , itemprop= )[ ]
            startdates.append(startdate)

            enddate = x.find_next( , itemprop= )[ ]
            enddates.append(enddate)

            councils.append(council)

            uniquekey = hashlib.sha224(str(link + startdate).encode( )).hexdigest()
            uniquekeys.append(uniquekey)

driver.quit() for in 'eventsList eventSection' "" "" "" "" "href" "span" "startDate" 'content' "span" "stopDate" 'content' 'utf-8' I didn't strictly need to put this in a dataframe, but it worked better with pangres, and I might extend the code to do some transformation. # put data a dataframe
# a df not strictly needed here, except pangres uses it

df = pd.DataFrame({ :uniquekeys, :links, :titles, : startdates, : enddates, : councils,
})

# set an index, code below will need it; also removes ID
df.set_index( , inplace=True) in 'uniquekey' 'link' 'title' 'startdate' 'enddate' 'council' as this default 'uniquekey' Here's the table definition for reference. # CREATE TABLE (
# TEXT primary key,
# TEXT,
# TEXT,
# TEXT,
# TEXT,
# TEXT,
# DATETIME DEFAULT CURRENT_TIMESTAMP 
# ); "events" "uniquekey" "link" "title" "startdate" "enddate" "council" "updateddate" Because the events didn't have a created date, I added an automatic create date to allow me to identify new entries and then the pangres library to do upserts to sqlite. This allows me to identify new entries and potentially send a notification email with that listing. engine = create_engine( )

upsert(engine=engine,
       df=df,
       table_name= ,
       if_row_exists= ,
       dtype=None) 'sqlite:////tmp/gs.sqlite' 'events' 'update' I can easily view the data stored in sqlite via TablePlus. Finally, I ran a quick delete on events that had expired. sqlalchemy text

deleteExpiredSQL = f engine.connect() connection:
    result = connection.execute(text(deleteExpiredSQL)) from import "delete from events where enddate<'{str(datetime.now())}'" with as I can run this periodically now to find new events to share with my daughter. Right now, I don't want to put it on cron, but that's an option in the future. (base) vparham@Valeries-Air girlscoutevents % python gs-events.py The complete code is here: https://github.com/dataindataout/girlscoutevents

Automation for Girl Scout Events

Introduction This article is a logical continuation of upgrading the nopCommerce project - a free open-source CMS for creating online stores. Last time we talked about in migrating nopCommerce from ASP.NET MVC to ASP.NET Core 2.2. In this article, we will look at the migration to .NET Core 3.1. .NET Core 3.1 will be until December 2022, so migration is a hot topic right now. If you want to take full advantage of the updated framework, keep up with technological innovations, and the growing global trends then it's time to start the migration. our experience officially supported Challenges to be solved in the process of migration to .Net Core 3.1 For the fast-growing eCommerce project, it is imperative to pay great attention to system performance and security. In the first .NET Core 3.0 review, it was announced that the new version of the framework will be much more fast and productive. Implementing the following .Net Core 3.1 features push nopCommerce to the new level of scalability, performance and security: allows us to decrease startup time. Tiered compilation The new built-in high-performance and low-memory . support for JSON The endpoint routing introduced in .NET Core 2.2 has been improved. The main advantage is that the route is now determined before running the middleware. At the time of the release, our expectations were confirmed in practice. Next, let’s see what exactly affected the nopCommerce performance and how .NET Core evolved since the release of version 2.2. What's new in .NET Core 3.1 Let's take a closer look at the .NET Core 3.1 innovations that we use in nopCommerce. You can find the detailed instructions on on the official Microsoft website. In this article we will look at the benefits we receive using these innovations. how to migrate from .NET Core 2.2 to .NET Core 3.1 Generic Host In .NET Core 2.1 Generic Host is an addition to the Web Host. It allows you to use tools such as dependency injection (DI) and logging abstractions. .NET Core 3 emphasized the greater compatibility with Generic Host, so you can now use the updated Generic Host Builder instead of Web Host Builder. This allows to create any kind of application, from console applications and WPF to web applications, on the same basic hosting paradigm with the same common abstractions. {
            CreateHostBuilder(args).Build().Run();
        } { Host.CreateDefaultBuilder(args)
                .UseServiceProviderFactory( AutofacServiceProviderFactory())
                .ConfigureWebHostDefaults(webBuilder =>
                {
                    webBuilder
                        .UseStartup<Startup>();
                });
        }
    } public { class Program public static void Main ( [] args) string IHostBuilder public static CreateHostBuilder ( [] args) string return new You can still continue to use WebHostBuilder but you need to understand that some types are deprecated in ASP.NET Core 3.1, and may be replaced in the next version. global.json The idea and possibility of using this feature already existed in the .NET Core 2.0 version, but its capabilities were incomplete. It was only possible to specify the version of the SDK that your application is using. More flexible SDK version control became available only in .NET Core 3.0 with the introduction of policies such as and . The code below illustrates the use of the .NET Core SDK roll-forward policies. allowPrerelease rollForward { : { : , : , : }
} "sdk" "version" "3.1.201" "rollForward" "latestFeature" "allowPrerelease" false You can see the full version of the application code in . our repository on GitHub Now you can specify the version from which you can easily build the application, without having to edit global.json every time after the next patch is released. This way you can define the range of functionality that you need based on your requirements. It will also give you a guarantee that users of your application will run it exactly on those SDK assemblies that you have defined, and not the latest version installed on their server. ASP.NET Core Module V2 Prior to .NET Core 2.2, IIS hosted a .NET Core app by executing a Kestrel instance and forwarding requests from IIS to Kestrel by default. Basically IIS acted like a proxy. This works but is slow because there is a double hop from IIS to Kestrel while processing the request. This hosting method is called «OutOfProcess». .NET Core 2.2 introduced the new "InProcess" hosting model. Instead of forwarding requests to Kestrel, IIS serves requests inside itself. This makes the requests processing much faster because you don't need to forward the request to Kestrel. However, this was an optional feature and was not used by default. In .NET Core 3.1, the in-process hosting model is already configured by default, which significantly improves the throughput of ASP.NET Core requests in IIS. During testing, we recorded a significant increase in system performance with a large number of requests. netcoreapp3.1 Copyright (c) Nop Solutions, Ltd Nop Solutions, Ltd Nop Solutions, Ltd 4.4.0.0 Nop.Web is also an MVC web application project, a presentation layer for public store and admin area. https://www.nopcommerce.com/license https://www.nopcommerce.com/ https://github.com/nopSolutions/nopCommerce Git true InProcess false < > PropertyGroup < > TargetFramework </ > TargetFramework < > Copyright </ > Copyright < > Company </ > Company < > Authors </ > Authors < > Version </ > Version < > Description </ > Description < > PackageLicenseUrl </ > PackageLicenseUrl < > PackageProjectUrl </ > PackageProjectUrl < > RepositoryUrl </ > RepositoryUrl < > RepositoryType </ > RepositoryType  < > CopyLocalLockFileAssemblies </ > CopyLocalLockFileAssemblies < > AspNetCoreHostingModel </ > AspNetCoreHostingModel  < > RazorCompileOnPublish </ > RazorCompileOnPublish </ > PropertyGroup Note that running the application on Linux will still use the out-of-process web server hosting model. Also, if you host multiple in-process applications on your server, you must ensure that each such application has its own pool. Endpoint Routing In .NET Core 2.1, routing was done in Middleware (ASP.NET Core MVC middleware) at the end of the HTTP request pipeline. This means that information about the route, such as what controller action will be taken, was not available for the middleware that processed the request before the MVC middleware in the request pipeline. Starting with .NET Core 2.2, a new endpoint-based routing system was introduced. This routing concept addresses the aforementioned issues. Endpoint Routing is now built differently in .NET Core 3.1. The routing phase is separated from the call to the endpoint. This way we have two intermediate middlewares: - calls the endpoint EndpointMiddleware - this determines which endpoint will be called for each path of the URL request and essentially acts as a routing EndpointRoutingMiddleware The application defines the endpoint to be shipped early in the middleware pipeline. The following middleware can use this information to provide functionality that is not available in the current pipeline configuration. { application.UseRouting(); application.UseEndpoints(endpoints =>
    { EngineContext.Current.Resolve<IRoutePublisher>().RegisterRoutes(endpoints);
    });
} /// <summary> Configure Endpoints routing /// /// </summary> Builder for configuring an application's request pipeline /// <param name="application"> </param> ( ) public static void UseNopEndpoints IApplicationBuilder application this //Add the EndpointRoutingMiddleware //Execute the endpoint selected by the routing middleware //register all routes You can learn more about the code in . our repository on GitHub С# 8.0 syntactic sugar In addition to updating the .NET Core itself, a new version of C # 8.0 was also released. There are a lot of updates. Some of them are fairly global, others involve cosmetic improvements, giving developers "syntactic sugar". You can find a detailed description in the . documentation Performance evaluation After we upgraded our nopCommerce application, it was necessary to check how performance increased in our case. For users, this is one of the most important criteria when choosing an eCommerce platform. Tests were run on Windows 10 (10.0.19041.388), where IIS 10 (10.0.19041.1) acted as a proxy for the Kestrel web server on the same machine. To simulate the high load, we used Apache JMeter, which allows us to simulate a very serious load with many parallel requests. For the test, we have specially prepared a database typical for an average online store. The number of products was about 50,000 items, the number of product categories was 516 with random nesting, the number of registered users was about 50,000, and the number of orders was about 80,000 with a random inclusion of 1 to 5 products. All this was running by MS SQL Server 2017 (14.0.2014.14). JMeter ran multiple load tests generating a summary measurement report for each request each time. The averaged results after several runs are presented below. Test time is about 20% faster (less is better). The average response time is about 13.7% faster (less is better). The number of requests per unit of time (throughput) increased by 12.7% (more is better). We also measured actual memory usage of the application after launch and after a short-term load test. The test was carried out in a few consecutive series. Our goal was to find out how efficiently the application frees the memory. And how the ASP.NET Core module update affected the starting memory consumption. Let us remind you that we started using the new “InProcess” model. The results are presented in the diagram above. In-process model shows more than 1.5 times better efficiency after passing the first load cycle. Further, more efficient use of resources is observed. By the end of the third cycle of load tests, the total memory consumption is more than 2 times more efficient in comparison with out-of-process allocation. This is a very good result. For comparison, we provide a table with test results including the AspNetCoreModule which we used with .NET Core 2.2. The new module undoubtedly outperforms its predecessor. The starting memory consumption remained almost unchanged. Conclusion The .NET Core platform migration process is still cumbersome and time-consuming. And if you make updates on time and consistently, this will help you to avoid a lot of mistakes and save your time. Many aspects of .NET Core have been improved and you get as a bonus. better performance In our particular case, we got an average performance increase of 13%. Now requests to the application run faster. This allows you to send more data in less time which makes the application more comfortable to use. Therefore, this is quite a significant increase, considering that you do not actually need to do performance refactoring of your application. You simply update the framework and get an overall improvement of the platform performance. It is also important to note that, as always, .NET Core pays a lot of attention to security issues. By the way, since the release of .NET Core 3.1.0, a number of updates have already been released (the latest version is currently 3.5.1) including security updates. A very important point is that .NET Core 3.1 is the next LTS version after 2.1, which guarantees us and our customers support and receiving the latest fixes, including security patches. Therefore, it is important for us to move forward with the release of the LTS versions of .NET Core. will be the next global release, and moving your application to .NET Core 3.1 is the best way to prepare for that. .NET 5 In the future, we plan to further update the nopCommerce, adding more and more new features that the .NET Core platform provides. One of them is using instead of . System.Text.Json Newtonsoft.Json This is a more performant, safe, and more standardized approach to handling JSON objects. We also plan to implement and use as many features as possible that C # 8.0 provides. You can learn more about our project on or by visiting . nopcommerce.com our repository on GitHub

ENGINR.CO

enginr.co

-- employees

Since n.d.

COMPANY RANKING

ENGINR.CO

EVERGREEN INDEX #3489

Representing this company? Click here to claim and customize this page!

EnginR.co WIKI

Apply to get your Tech Company News Page live on HackerNoon.com today!

ENGINR.CO

enginr.co

-- employees

Since n.d.

COMPANY RANKING

ENGINR.CO

EVERGREEN INDEX #3489

RELATED COMPANIESRANK

STORIES ABOUT ENGINR.CO

Representing this company? Click here to claim and customize this page!

EnginR.co WIKI

Apply to get your Tech Company News Page live on HackerNoon.com today!