EditArticle

Edit Article XML Content

<document> <header> <issuecode /> <articlecode /> <zone /> <title /> <authors /> <copyright>CODE Magazine</copyright> <owner>CODE Magazine</owner> </header> <body> Job-Oriented Programming and Pointers in a Scripting Language This article is about using job-oriented programming and pointers in a scripting language. As a scripting language, we’ll use CSCS (Customized Scripting in C#). This is an easy and a lightweight open-source language that has been described in previous CODE Magazine articles: https://www.codemag.com/article/1607081 introduced it, https://www.codemag.com/article/1711081 showed how you can use it on top of Xamarin to create cross-platform native mobile apps, and https://www.codemag.com/article/1903081 showed how you can use it for Unity programming. CSCS resembles JavaScript with a few differences, such as the variable and function names being case-insensitive. In this article, we’ll be talking about job-oriented programming as implemented in CSCS. Every office job, like print invoice, create offer, manage customer data, manage product data, print accounting list, etc., has its counterpart in appropriate menu system of business application used. Behind any menu item, there’s separate program micro-module. Such micro-modules can interact with each other, calling "child" micro-modules and passing parameters to them. Calling a child micro-module is done by simple Chain command, at any line of code. When the "chained" job is done, program execution proceeds with the next line of the parent job (the one that executed the Chain command). This way, you can easily develop even huge applications using any number of standalone micro-modules. You can also send any parameters to the chained-to program (the child) and return any data from the child program. This way, you can chain from one program to another, any level deep. Any micro-module can be executed from menu or using Chain command from another micro-module. This gives developers the freedom to work on a program independently from one another, as a micro-module is self-sufficient regarding the job that it has to do. Passing parameters is just an option. To facilitate independent development, you need to define parameters that will be used for communication between scripts in case the parameters are needed. This makes any modifications of the whole application very easy, changing only one micro-module. All this functionality has been made with only two functions: Chain and Param. The syntax is simple: <codesnippet> CHAIN » programName » WITH » arguments ; </codesnippet> The chained-to program (the child program) can listen for arguments with: <codesnippet> PARAM » parameters ; </codesnippet> The arguments can be constants, variables, or expressions, or any combination. Parameters can be a single variable, an array, or a tuple. From a child program, you can access any variable from a previous (parent) program programmatically. You can also return any value from child to parent programmatically. Let’s see how to use CHAIN/PARAM scripting commands in a C# project, taking as an example a WPF (Windows Presentation Foundation) project. In addition to the CHAIN/PARAM functionality, we’ll also look at how to use pointers in a scripting language. It’s important to note that usually, the main piece of code is in a compiled language (such as C#), but only a part of the project is done in CSCS scripting. There’s an obvious benefit: You don’t have to re-compile anything if you change scripting code, because the scripting will be loaded at runtime. Another benefit of scripting is that you can load scripts, XAML files, and images on the fly from your server. This way, you can get a new version of your client without a formal release! We’ll show how to do this in this article. Let’s start by looking at definition of a chain and how chains can be used in scripting. <h2>Setting Up the CSCS Scripting Environment</h2> Probably the simplest way to start using CSCS scripting is to download the source code from GitHub (see https://github.com/vassilych/cscs) and add the source code directly to your C# .NET project. The license lets you modify and use the code without restrictions. As an example of adding CSCS scripting to a WPF project, take a look at https://github.com/vassilych/cscs_wpf. This is already a preset WPF project with scripting added. There you can also consult the full implementation of the functionality that you’ll see in this article. Take a look at a previous CODE Magazine article: https://www.codemag.com/Article/2008081. It explains how to use WPF with CSCS scripting. Once you set up the project structure, you can explore the possibilities of the customized scripting that you might not have explored before. <h2>Using Chains in Scripting</h2> In this section, you’ll see a cool feature of starting new scripts from a parent script. Also, you’ll see how to pass parameters between these scripts. <h3>Running Child Scripts in the Same Process Space</h3> A sample code for a simple CHAIN functionality is the following: <codesnippet> CHAIN » "D:/scripts/scriptName.cscs " ; </codesnippet> This runs the specified script and waits until it finishes. You can also specify the default scripts folder in the standard C# project appSettings configuration file (.config). Here’s an example: <codesnippet> <add » key = " ScriptsPath " » value = "D:/scripts/" /> </codesnippet> In this case, you can use the path above with the special tpath() function: <codesnippet> CHAIN » tpath ( )+" scriptName.cscs "; </codesnippet> The tpath() is a CSCS function that returns the corresponding "ScriptsPath" path from the config file. Note that spaces are not allowed inside of an argument (e.g., in tpath()+"scriptName.cscs") because the spaces are the argument separators, as you will see in examples below. You can also provide parameters for the chained-to script in a simple way: <codesnippet> CHAIN » " scriptName.cscs " » WITH » arg1 » arg2 » arg3 ; </codesnippet> Example: <codesnippet> CHAIN » tpath ( )+" scriptName.cscs "»WITH»"string1" </codesnippet> <codesnippet> »»»»»»variable2» userFunction ( arg ); </codesnippet> Here, string1 is a string constant, variable2 can be variable of any type, even an array variable of any size, and userFunction() can be any user defined function. <h3>Running Child Scripts in a New Process Space</h3> All chained (child) scripts in the previous section run in the same process space. If you want to run the script in another process, there’s another syntax of the CHAIN command: <codesnippet> CHAIN » tpath ( )+" scriptName.cscs "»NEWRUNTIME»WITH </codesnippet> <codesnippet> »»»»»»"arg1"»"arg2"»"arg3"»"arg4"; </codesnippet> In the command above, the NEWRUNTIME keyword tells the interpreter to run the script in another process. Later on, you’ll see an example of a script started in a new runtime environment. <h3>Receiving Arguments in the Child Script and Passing Them Back to the Parent Script</h3> Consider a child script, scriptName.cscs, started from the parent’s script CHAIN command in the previous section. That example contains four arguments, passed from the parent: strings "arg1", "arg2", "arg3", and "arg4". In the chained (child) script, the arguments from the parent script are received as follows: <codesnippet> PARAM ( param1 ,» param2 ,» param3 ,» param4 ); </codesnippet> After running the PARAM command above, the chained script sets its local variables as follows: <codesnippet> param1 » = » "arg1" ;» param2 » = » "arg2" ; </codesnippet> <codesnippet> param3 » = » "arg3" ;» param4 » = » "arg4" ; </codesnippet> These four variables are local to the chained script and won’t be known to the parent. It’s also possible to have a two-way exchange of the parameters between the child and the parent script. The syntax is as follows: <codesnippet> ResetField ( scriptName ,» variableName ); </codesnippet> For example: <codesnippet> ResetField ( " scriptName.cscs " ,» " varNameInParent " ); </codesnippet> After running this command, the chained script has access to the variable defined in the parent script, with the name "varNameInParent". Not only is it going to have access to the variable, but also all of the modifications done to "varNameInParent" are visible in the parent script. Using the ResetField() command, the child can do both—have access to all of the variables in the parent script, and also to set any variable in the parent—so that after the child is finished, the parent has had all of its variables modified. Note that the "varNameInParent" variable doesn’t have to exist—the child can create it in the parent space and set it to whatever value (including a number, a string, a tuple, etc.) it needs. <h2>Hello, World! Example in Chaining</h2> In this section, you’ll see an example of chaining scripts using CSCS scripting language in a WPF C# project. The entry point of the first script to be executed is defined in the project .exe.config configuration file using the "CSCS_Init" key. Here’s what we use in the example: <codesnippet> <add » key = " CSCS_Init " » </codesnippet> <codesnippet> »» value = "C:/cscs_wpf/scripts/demoMenu.cscs" /> </codesnippet> The full code of the demoMenu.cscs is shown in Listing 1. Note that the first thing the script does is create a new WPF window: <codesnippet> CreateWindow ( tpath ( )» + » " demoMenuWindow.xaml " ); </codesnippet> The full code of the demoMenuWindow.xaml file is shown in Listing 2. As you can see, this is a typical XAML file used in any WPF project. Basically, it just creates a WebView based on the https://github.com/vassilych/cscs website and a simple menu. This entry window is shown in Figure 1: <figure id="1" src="image1.png"> Figure SEQ Figure \* ARABIC 1 : The entry Window after starting a sample project.</figure> At the next step, choose "Run script1" menu entry. The demoMenu.cscs initializes the menus as follows: <codesnippet> function » demoMenuWindow_ OnDisplay ( )»{ </codesnippet> <codesnippet> »» AddMenuItem ( " mainMenuDC " ,» " ScriptsDC " , </codesnippet> <codesnippet> .»»»»»»»»»»»»»"Scripts" ); </codesnippet> <codesnippet> »» AddMenuItem ( " ScriptsDC " ,» "demoScript1.cscs" , </codesnippet> <codesnippet> »»»»» »»»»»»»»» "Run»script1" ,» " runScript " ); </codesnippet> <codesnippet> »» AddMenuItem ( " ScriptsDC " ,» "exit" ,» "Exit" , </codesnippet> <codesnippet> »»»»» »»»»»»»»» " runScript " ); </codesnippet> <codesnippet> } </codesnippet> AddMenuItem() is an auxiliary CSCS function that adds an entry to a particular menu. Here’s the CSCS definition of the RunScript function that it uses: <codesnippet> function » runScript ( sender,»load)»{ </codesnippet> <codesnippet> »» if »( sender »==» "exit" )»{ </codesnippet> <codesnippet> »»»»» exit ; </codesnippet> <codesnippet> »»} </codesnippet> <codesnippet> //»execute»a»script»from»the»sender. </codesnippet> <codesnippet> »» CHAIN » tpath ()+ strTrim ( sender ); </codesnippet> <codesnippet> } </codesnippet> Once the user clicks "Run Script1" menu option, the demoScript1.cscs is triggered (see Listing 3). That script creates a new window (see Listing 4.). That window is shown in Figure 2. <figure id="2" src="image2.png"> Figure 2: The result of clicking Run Script1 menu</figure> Here we have two buttons; both of them trigger the execution of the demosScript2.cscs script (see Listing 5). The left button triggers the execution in the same process and the right one triggers the execution in a new process space. In any case, as you can see from Listing 5, the first thing the script does is to create a new window, demoScript2.xaml (see Listing 6). The new window, created after the chaining, is shown in Figure 3. <figure id="3" src="image3.png"> Figure 3: The chained script (the child)</figure> Both windows (in Figure 2 and in Figure 3) show some graphics. These graphics are parts of the LiveCharts (https://v0.lvcharts.com), an MIT license package that can used as a NuGet package. You can check out how you can create cool graphics from this package in Listing 3 (Pie Chart) and Listing 5 (Normal line chart)). <h2>Downloading Resources from the Internet</h2> In this section, you’ll see how to get the resources (all text, .cscs, and .xaml files, and any images) from the internet. The CSCS function to access a file, located somewhere on the internet, is the following: <codesnippet> Download ( fullFilename ); </codesnippet> Note that the webserver where you store your files for downloading must be configured to treat .xaml and .cscs files as text files. Usually, this is already done by default for the .xaml files. <pullquote>The webserver where you store files for downloading must be configured to treat .cscs files as text files.</pullquote> For the .cscs files, change the MIME types on the IIS Manager page, as shown in Figure 4. <figure id="4" src="image4.png"> Figure 4: Changing MIME types on the server IIS Manager</figure> After setting up your webserver for downloading the .cscs fies, you can access them as follows: <codesnippet> newXamlFile » = » Download (» " http://185.32.126.169/ </codesnippet> <codesnippet> shared/ winWithButtons.xaml " ); </codesnippet> You can also do the chaining, explored in the previous section, using scripts from the internet: <codesnippet> CHAIN » Download ( "http://185.32.126.169/ </codesnippet> <codesnippet> shared/script5.cscs" ); </codesnippet> This statement means that script5.cscs will be downloaded from an internet location and will be immediately started with just one line of code! Alternatively, you can download the version of your program and then, if it’s not up to date, you can download a new version of the CSCS and /or the XAML files. Here’s a simple pseudo-example how to do it in CSCS: <codesnippet> v » = » Download ( </codesnippet> <codesnippet> »» "http://185.32.126.169/shared/version.txt" ); </codesnippet> <codesnippet> lines » = » readfile ( v ); </codesnippet> <codesnippet> version » = » lines [ 0 ]; </codesnippet> <codesnippet> if »( myVersion » < » version )»{ </codesnippet> <codesnippet> »» newScriptFile » = » Download ( »»» </codesnippet> <codesnippet> »»» "http://185.32.126.169/shared/script5.cscs" ); </codesnippet> <codesnippet> »» copy ( newScriptFile ,» programScriptsDir ); </codesnippet> <codesnippet> »» newXamlFile » = » Download ( </codesnippet> <codesnippet> »»»» "http://185.32.126.169/shared/win5.xaml" ); </codesnippet> <codesnippet> »» copy ( newXamlFile ,» programXamlDir ); </codesnippet> <codesnippet> } </codesnippet> In the same way, you can download images or any other files as well. <h2>Introduction to Pointers in Scripting</h2> Another nice feature that we’d like to introduce in CSCS scripting language is pointers. Pointers work and look similar to the C/C++ pointers (but not the same though: to dereference a pointer, e.g., to access the value of a variable that it points to, use "&" instead of "*"). An important difference is that you don’t have to explicitly allocate and delete the memory to which your pointer points. After a pointer is defined and initialized to point to a variable, as soon as you change the value of the pointer, the value of the variable to which it points will be changed as well. Also, if you change the value of a variable, the pointer value will also be changed. Here’s an example from Listing 5: <codesnippet> //»A»pointer»must»be»first»defined»with» </codesnippet> <codesnippet> //»a»DEFINE»keyword </codesnippet> <codesnippet> DEFINE » aPointer » type » f ; </codesnippet> <codesnippet> aPointer » -> » var1 ; </codesnippet> <codesnippet> //» aPointer »points»now»to»a»variable»var1 </codesnippet> <codesnippet> var1 » = » 100 ; </codesnippet> <codesnippet> //»Now»the»value»of»& aPointer »will»be»100 </codesnippet> <codesnippet> & aPointer » = » 200 ; </codesnippet> <codesnippet> //»Now»the»value»of»var1»will»be»200 </codesnippet> <h2>Wrapping Up</h2> In this article, you saw how you can use chains in a scripting language. It’s possible to use script chaining to any level, i.e., you can script from the MainMenu script to script1 then from script1 to script2, and so on. When you quit any script (using the Quit command) the script execution proceeds from the next line after the chain command in the previous (parent) script. Such an implementation can enable even huge applications to be split into many isolated scripts. This is a great advantage for developers who need to independently develop scripts without conflicting with scripts from other developers. As you can see, updating any application may be very easy with simple change of a single script and not of the whole application. We’re looking forward to your feedback, specifically, your experience in scripting with chains and downloading scripts from the internet. Also, we’ll be excited to hear what other features in CSCS you would like to see. </body> <sidebars> <sidebar title="References"> CSCS Repository: https://github.com/vassilych/cscs CSCS WPF Repository: https://github.com/vassilych/cscs_wpf CSCS Visual Studio Code Debugger Extension: https://marketplace.visualstudio.com/items?itemName=vassilik.cscs-debugger </sidebar> </sidebars> <tables /> <codelistings> <codelisting id="1" header="Listing 1: demoMenu.cscs : Main Menu Script"> <code> //»Create»main»menu» window; </code> <code> //» tpath »gets»the»location»of»the»scripts»folder </code> <code> CreateWindow ( tpath ( ) + " demoMenuWindow.xaml " ); </code> <code /> <code> define » mainMenuDC » type » a ; </code> <code /> <code> function » demoMenuWindow_ OnDisplay ( ){ </code> <code> »» AddMenuItem ( " mainMenuDC " ,» " ScriptsDC " ,» "Scripts" ); </code> <code> »» AddMenuItem ( " ScriptsDC " ,» "demoScript1.cscs" , </code> <code> »»»»»»»»»»»»»» "Run»script1" ,» " runScript " ); </code> <code> »» AddMenuItem ( " ScriptsDC " ,» "exit" , </code> <code> »»»»»»»»»»»»»» "Exit" ,» " runScript " ); </code> <code> } </code> <code /> <code> //»function»for»starting»scripts»from»main»menu </code> <code> function » runScript ( sender,»load){ </code> <code> »» if ( sender » == » "exit" ){ </code> <code> »»»»» //»exits»the»exe»program </code> <code> »»»»»» exit ; </code> <code> »»} </code> <code> »» CHAIN » strTrim ( tpath ( )) + strTrim ( sender ); </code> <code> } </code> </codelisting> <codelisting id="2" header="Listing 2: demoMenuWindow.xaml: Main Menu Window"> <code> <Window » xmlns = </code> <code> "http://schemas.microsoft.com/ winfx /2006/ xaml / </code> <code> »»presentation" </code> <code> xmlns:x = </code> <code> »» "http://schemas.microsoft.com/ winfx /2006/ xaml " </code> <code> xmlns:d = </code> <code> » "http://schemas.microsoft.com/expression/blend/2008" </code> <code> xmlns:mc = </code> <code> "http://schemas.openxmlformats.org/ </code> <code> »»markup-compatibility/2006" </code> <code> xmlns:local = " clr-namespace:WpfCSCS " </code> <code> xmlns:WPF = </code> <code> "clr- namespace:Microsoft.Web .WebView2.Wpf; </code> <code> » assembly=Microsoft.Web.WebView2.Wpf " </code> <code> »»»»»»»» mc:Ignorable = "d" </code> <code> »»»»»»»» Title = "Main»menu" » Height = "450" » Width = "800" » </code> <code> WindowStartupLocation = " CenterScreen " > </code> <code> »» <Grid> </code> <code> »»»» < Grid.RowDefinitions > </code> <code> »»»»»» < RowDefinition » Height = "auto" » /> </code> <code> »»»»»» < RowDefinition » Height = "*" » /> </code> <code> »»»» </ Grid.RowDefinitions > </code> <code> »»»» < WPF:WebView 2 » Grid.Row = "1" </code> <code> »»»»»»»»»»»»» x:Name = "WebView1" </code> <code> »»»»»»»»»»»»» Margin = "0,0,0,0" </code> <code> »»»»» Source =» "https://github.com/ vassilych / cscs " » /> </code> <code> »»»»»»» <Menu » Grid.Row = "0" </code> <code> »»»»»»»»»» DataContext = " mainMenuDC " </code> <code> »»»»»»»»»»» Name = " mainMenuDC " » /> </code> <code> »» </Grid> </code> <code> </Window> </code> </codelisting> <codelisting id="3" header="Listing 3: demoScript1.cscs: First Script triggered from the Menu"> <code> CreateWindow ( tpath ( ) +"demoScript1.xaml" ); </code> <code /> <code> function » demoScript1_ onDisplay ( ){ </code> <code> »»»» PieChart ( "dougnutChart1" ,» " init " ); </code> <code> »»»» PieChart ( "dougnutChart1" ,» "values" ,» 50 , </code> <code> »»»»»»»»»»»»» " label »1" ,» 50 ); </code> <code> »»»» PieChart ( "dougnutChart1" ,» "values" ,» 150 , </code> <code> »»»»»»»»»»»»» " label »2" ,» 50 ); </code> <code> »»»» PieChart ( "dougnutChart1" ,» "values" ,» 250 , </code> <code> »»»»»»»»»»»»» " label »3" ,» 50 ); </code> <code> »»»» PieChart ( "dougnutChart1" ,» "values" ,» 350 , </code> <code> »»»»»»»»»»»»» " label »4" ,» 50 ); </code> <code> »»»» PieChart ( "dougnutChart1" ,» "colors" , </code> <code> »» {» " #1C4E80" ,» "#EA6A47" ,» "#5acc6b" ,» "#34d2fa" »}); </code> <code> } </code> <code /> <code> //»button»clicked»event,»starts»a»new»script»and </code> <code> //»sends» parameters( "Hello"»-»constant» </code> <code> //»and»var1»-»variable) </code> <code> function » button1 @ clicked ( ){ </code> <code> »» var1 » = » "»World!" ; </code> <code> »» CHAIN » strTrim ( tpath ( )) +"demoScript2.cscs" </code> <code> »»»»»»»»»» WITH » "Hello" » var1 ; </code> <code> } </code> <code /> <code> //»Same»as»function»above»but»starts»a»script»in </code> <code> //»a»new»process </code> <code> function » button2 @ clicked ( ){ </code> <code> »» var1 » = » "» World!( NEWRUNTIME)" ; </code> <code> »» CHAIN » strTrim ( tpath ( )) +"demoScript2.cscs" » </code> <code> »»»»»»»» NEWRUNTIME » WITH » "Hello" » var1 ; </code> <code> } </code> </codelisting> <codelisting id="4" header="Listing 4: demoScript1.xaml: Window of Script1"> <code> <Window » xmlns = </code> <code> "http://schemas.microsoft.com/ winfx /2006/ xaml / </code> <code> »»presentation" </code> <code> »» xmlns:x = </code> <code> »» "http://schemas.microsoft.com/ winfx /2006/ xaml " </code> <code> »» xmlns:d = </code> <code> » "http://schemas.microsoft.com/expression/blend/2008" </code> <code> »» xmlns:mc = </code> <code> "http://schemas.openxmlformats.org/ </code> <code> »»»markup-compatibility/2006" </code> <code> »»» xmlns:local = " clr-namespace:WpfCSCS " </code> <code> »»» xmlns:lvc = " clr - </code> <code> » namespace:LiveChartsCore.SkiaSharpView.WPF ; </code> <code> »»assembly= LiveChartsCore.SkiaSharpView.WPF " </code> <code> »» mc:Ignorable = "d" </code> <code> »» Title = "Script»1" » Height = "450" » Width = "500" » </code> <code> »»»» WindowStartupLocation = " CenterScreen " > </code> <code> »» <Grid> </code> <code> »»»» < lvc:PieChart » LegendPosition = "Bottom" </code> <code> »»»»»»»»»»»» Name = "dougnutChart1" </code> <code> »»»»»»»»»»»» VerticalAlignment = "Top" </code> <code> »»»»»»»»»»»» HorizontalAlignment = "Left" </code> <code> »»»»»»»»»»»» Width = "490" </code> <code> »»»»»»»»»»»» Height = "289" </code> <code> »»»»»»»»»»»» FontSize = "10" </code> <code> »»»»»»»»»»»» Margin = "0,0,0,0" » /> </code> <code> »»»» <Button » Name = "button1" </code> <code> »»»»»»»»»»»» Content = "CHAIN»to»script»2" </code> <code> »»»»»»»»»»»» HorizontalAlignment = "Left" </code> <code> »»»»»»»»»»»» Margin = "90,334,0,0" </code> <code> »»»»»»»»»»»» VerticalAlignment = "Top" </code> <code> »»»»»»»»»»»» Height = "60" </code> <code> »»»»»»»»»»»» Width = "115" » /> </code> <code> »»»» <Button » x:Name = "button2" </code> <code> »»»»»»»» Content = "CHAIN»to»script»2(NEWRUNTIME)" </code> <code> »»»»»»»» HorizontalAlignment = "Left" </code> <code> »»»»»»»» Margin = "250,334,0,0" </code> <code> »»»»»»»» VerticalAlignment = "Top" </code> <code> »»»»»»»» Height = "60" </code> <code> »»»»»»»» Width = "210" » /> </code> <code> »» </Grid> </code> <code> </Window> </code> </codelisting> <codelisting id="5" header="Listing 5: demoScript2.cscs: script triggered by demoScript1.cscs"> <code> CreateWindow ( tpath ( ) +"demoScript2.xaml" ); </code> <code /> <code> DEFINE » aPointer » type » f ;» //»pointer»type </code> <code> DEFINE » var1 » type » i » size » 10 ;» //»integer»variable </code> <code /> <code> function » demoScript2_ onInit ( )»{ </code> <code> »» //»PARAM»will» recieve »parameters»sent»from </code> <code> »» //»the»previous»script. </code> <code> »» //»They»will»be»named»arg1»and»arg2»in»this»script </code> <code> »» PARAM ( arg1 , arg2 ); </code> <code> »» //»Show»arguments </code> <code> »» MessageBox ( arg1 » + » arg2 ); </code> <code /> <code> »» //» aPointer »points»to»var1 </code> <code> »» aPointer » -> » var1 ; </code> <code /> <code> »» var1 » = » 100 ; </code> <code> »» MessageBox ( "var1»=»" » + » var1 » + » " , </code> <code> »»»»»»»»»»»»»» & aPointer » = » "»+»& aPointer ) ; </code> <code> »» & aPointer » = » 200 ; </code> <code> »» MessageBox ( "var1»=»" » + » var1 » + » " , </code> <code> »»»»»»»»»»»»»» & aPointer » = » "»+»& aPointer ) ; </code> <code> } </code> <code /> <code> function » demoScript2_ onDisplay ( ){ </code> <code> »» Chart ( " LineChart " ,» " init " ); </code> <code> »» //»x»labels»first,»with»font»size»of»12» px </code> <code> »» Chart ( " LineChart " ,» " labels" , "x " ,» 12 , </code> <code> »{ "1" ,» "2" ,» "3" ,» "4" ,» "5" ,» "6" ,» "7" ,» "8" ,» "9" ,» "10" }); </code> <code> »» Chart ( " LineChart " ,» " SeparatorStep " ,» 1 ); </code> <code> »» //»set»of»values»for»the»first»line»chart </code> <code> »» Chart ( " LineChart " ,» "values" ,» "line" ,» </code> <code> »{ 100 ,» 512 ,» 265 ,» 300 ,» 1000 ,» 456 ,» 365 ,» 111 ,» 900 ,» 800 },» </code> <code> »»»» "Sample»data»1" ); </code> <code> »» //»set»of»values»for»the»second»line»chart </code> <code> »» Chart ( " LineChart " ,» "values" ,» "line" , </code> <code> »»{ 30 ,» 500 ,» 345 ,» 456 ,» 567 ,» 678 ,» 789 ,» 890 ,» 500 ,» 200 },» </code> <code> »»» "Sample»data»2" ); </code> <code> »» //»define»colors»of»the»first»and»the»second»line </code> <code> »» Chart ( " LineChart " ,» " Color.Series " ,» </code> <code> »»»»»»»» {» " #0091D5" ,» "red" });» </code> <code> } </code> <code /> <code> function » exitButton @ clicked ( ){ </code> <code> »» //»exit»from»the»script»and»return»to»the </code> <code> »» //»previous(parent)»script </code> <code> »» quit ; </code> <code> } </code> </codelisting> <codelisting id="6" header="Listing 6: demoScript2.xaml: Window of Script2"> <code> <Window » xmlns = </code> <code> » "http://schemas.microsoft.com/ winfx /2006/ xaml / </code> <code> »»»presentation" </code> <code> »» xmlns:x = </code> <code> » "http://schemas.microsoft.com/ winfx /2006/ xaml " </code> <code> xmlns:d = </code> <code> » "http://schemas.microsoft.com/expression/blend/2008" </code> <code> xmlns:mc = </code> <code> » "http://schemas.openxmlformats.org/markup- </code> <code> »»»»compatibility/2006" </code> <code> »» xmlns:local = " clr-namespace:WpfCSCS " </code> <code> »» xmlns:lvc = </code> <code> » " clr- namespace:LiveChartsCore.SkiaSharpView.WPF ; </code> <code> »»assembly= LiveChartsCore.SkiaSharpView.WPF " </code> <code> »» mc:Ignorable = "d" </code> <code> »» Title = "Script»2" » Height = "450" » Width = "500" » </code> <code> »»»»» WindowStartupLocation = " CenterScreen " > </code> <code> »» <Grid> </code> <code> »» < lvc:CartesianChart » LegendPosition = "Top" </code> <code> »»»»»»»»»»»»»»»»»»»»»» x:Name = "LineChart" </code> <code> »»»»»»»»»»»»»»»»»»»»»»»» Margin = "0" </code> <code> »»»»»»»»»»»»»»»»»»»»»»»» Height = "294" </code> <code> »»»»»»»»»»»»»»»»»»»»»»»» Width = "500" </code> <code> »»»»»»»»»»»»»»»»»»»»»»»» HorizontalAlignment = "Left" </code> <code> »»»»»»»»»»»»»»»»»»»»»»»» VerticalAlignment = "Top" » /> </code> <code> »»»» <Button » Name = " exitButton " </code> <code> »»»»»»»»»»»» Content = "Exit" </code> <code> »»»»»»»»»»»» HorizontalAlignment = "Left" </code> <code> »»»»»»»»»»»» Margin = "190,324,0,0" </code> <code> »»»»»»»»»»»» VerticalAlignment = "Top" </code> <code> »»»»»»»»»»»» Height = "60" </code> <code> »»»»»»»»»»»» Width = "115" » /> </code> <code> »» </Grid> </code> <code> </Window> </code> </codelisting> </codelistings> </document>

Add New Technology/Category
Category Name: *	(Example: .NET)
Category Group: (optional)	(Example: .NET, Visual Studio, Web Development)