Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Wisej.NET 3.5 adds native support for hybrid applications running on all sorts of devices, including full offline support, and many enhancements to the .NET class library and the corresponding JavaScript widgets.
The latest Wisej.NET 3.5 is available on NuGet.
The Visual Studio 2019 and 2022 extension packages are linked below:
Wisej.NET 3.5 is now compiled against .NET 7. This means that existing .NET 6 projects that would like to use the latest version of 3.5 must update the target framework dependency.
Wisej.NET 3.5 is now able to run on iOS, Android, and MacOS devices using the EmbedIO server in a new Wisej.NET Hybrid shell build using MAUI's native integrations.
Wisej.NET Hybrid includes three new project templates for creating applications:
This project template is used to create a Wisej.NET Hybrid Client. The Client project builds and runs an executable (.exe, .apk, .ipa, etc.) that can be deployed on any desktop or mobile platform.
This template is based on .NET MAUI. You can interact with this project the same way you would with any other MAUI project.
Allows developers to build and deploy a traditional Wisej.NET application with the added ability of interacting with the Hybrid device's native functionalities.
This application is deployed to a remote web server such as IIS, Kestrel, or Nginx on Windows or Linux.
Alternatively, you can add the Wisej-3-Hybrid NuGet package to an existing Wisej.NET project.
To use native device functionalities, you must access this application through the Wisej.NET Hybrid Client Application
Allows developers to build and deploy applications that run entirely on the Hybrid device. The project template contains similar features to the Remote application template such as a Page control.
This project needs to be linked into the Wisej.NET Hybrid Client Application to use.
In 3.5 we also focused on extending the programming side of Wisej.NET with a number of enhancements to the object model, data a binding, the various components.
ListViewItem gained the new Visible property. It allows the application to hide items without having to remove and add them back to the Items collection.
All controls that show a label gained a new AutoToolTip
property. When set to true
and the text is truncated, it will automatically use the title attribute to show the full label as a native tooltip.
The Validation extender now supports the IDataErrorInfo interface and data binding. We also added the Enabled
property to the base ValidationRule class to allow the code to disable a specific validation rule without removing it from the Validation extender.
DataGridView exposes the CreateSummaryRow, CreateDataBoundColumn, and CreateDataGridViewColumnFromType methods as public virtual to allow an application to customize the grid's inner behavior and fully control the automatica creation of rows and columns.
The ErrorProvider extender allows a derived class to override its methods and fires the new ErrorChanged event to allow an application to customize error message and icons in a single location.
TextBox.Text
now converts all \n to \r\n when Multiline
is true
. Previously Wisej.NET allowed the browser to strip \r\n and instead return only \n as a new line.
Most controls have gained several new constructors, some with optional and default arguments, that allow developers to use the controls in code adopting a more flexible and easier syntax:
All basic methods in Control now return this
to allow code to chain calls:
Wisej.NET 3.5 includes a new theme for building dark-style applications. The new Bootstrap Dark theme (BootstrapDark-4) is based on the existing Bootstrap-4 light theme.
The new Chat control can be used to build conversations into an existing Wisej.NET application. The new chat control supports text and custom message types, allowing users to share any type of control or data in the conversation.
The new Signature control can be used to collect and export user signatures. The control includes undo, redo, image import/export, and line customization features.
See documentation: https://docs.wisej.com/extensions/extensions/signature
The new Pull to Refresh component can be used to trigger a refresh of a data source associated with a scrollable panel. All containers inheriting from ScrollablePanel support the Pull-to-Refresh component.
The new TesseractJS component allows developers to add real-time OCR scanning to the Wisej.Web.Ext.Camera control.
The new Dynamsoft Barcode & Scanning premium extension gives developers an enterprise-ready option for barcode scanning and text (OCR) scanning on the web.
Developers are required to purchase the following licenses from Dynamsoft:
Dynamsoft Barcode Reader – JavaScript Web SDK
Dynamsoft Document Normalizer – JavaScript Web SDK
The new Mobiscroll premium extension gives developers a suite of mobile-friendly controls and components to use in Wisej.NET applications.
Developers are required to purchase a license from Mobiscroll for use of any components. The Wisej.NET integration uses the Mobiscroll JavaScript integration.
We added a new Validation property extender to provide a modern, centralized, and flexible validation system to Wisej.NET applications.
Once you drop the new Validation component on a container at design time, all the controls are extended with a new property ValidationRules. You can assign multiple validation rules to any control.
You can use the Validation component also directly in code. Instead of setting the ValidationRules property in the designer, simply call validation.SetValidationRules(control, rules);
There are 7 built-in validation rules:
Required: Validates the presence of any value.
Email: Validates an email entry.
Decimal: Validates a decimal value.
Integer: Validates an integer value.
Currency: Validates a currency value.
Telephone: Validates a phone number using a validation mask.
Regex: Validates any value using a custom regular expression.
Each built-in rule has a set of custom properties in addition to the basic properties inherited from the abstract ValidationRule class.
When design mode, you can add and manage the validation rules using Visual Studio's collection editor; it will automatically load the built-in rules and any custom rule you may have added to your solution.
Once you add validation rules to a control, the Validation component will automatically attach to the control's Validating and Validated events and invoke the rules in sequence. When a rule fails to validate, it will set the InvalidMessage property of the control being validated, and set the e.Cancel property of the event to true.
👉 This is more or less what you do now in code when handling the Validating event. With the difference that now you can reuse the same validation rule for multiple controls in an easy way.
Build your own custom validation rule classes by extending Wisej.Web.ValidationRule. You can add any property and perform any validation procedure required by the application.
Using validation rule classes allows you to implement complex business rules for the validation of user-entered data in a single, reusable, place.
Example of a custom rule to enforce a minimum-age value:
Validation messages are typically displayed in an error tooltip by setting the InvalidMessage property of an editor control. A second way to show validation errors, is to use the ErrorProvider extender. However, an application would have to explicitly set the error message in code when processing the Validating event.
The Validation extender, and each Validation rule, expose the ErrorProvider property (accepting any implementation of the new IErrorProvider interface), allowing the validation system to display the error message anywhere!
On the control itself, the default.
Using the ErrorProvider extender.
On any custom implementation of the new IErrorProvider interface: i.e, a MessageBox, a slide-in Panel, any logger, etc.
We have also added two new interfaces:
IValidation. All controls Controls that support the InvalidMessage property and fire Validating and Validated now implement this interface. (it's similar to the IReadOnly or ILabel interfaces that normalize common features.)
IErrorProvider. Exposes the same two public methods implemented by the existing ErrorProvider component. Allows an application to have full control of where an how to show error information related to data field validation. The Label control now implements IErrorProvider.
Now any class can implement the IErrorProvider interface and be connected to either the Validation component or to any (even multiple) ValidationRule implementation.
The Wisej.Web.Label control implements the IErrorProvider interface and it automatically shows or hides itself when an error message is set or cleard.
The code below shows a simple custom IErrorProvider that collects the errors and displays them in a list, all at once, in a MessageBox.
Validation rules are invoked twice, on Validating and on Validated events. A validation rule implementation may alter the text of a control while it's being validated or after it has been successfully validated.
For example, the built-in CurrencyValidationRule exposes a boolean Format property. When set to true, the rule will format the value of the control, if successfully validated, to display the currency symbol and the correct number of decimals.
The Validation extender exposes the same Validating and Validated events that are available to any control. However, for the Validation extender these events are fired for the controls that have been associated to at least one validation rule.
Your handler code attached to the Validation extender will receive the array with all the validation rules associated with the control being validated. This feature allows an application to perform additional custom validation at the Validation extender level, for all the related controls.
We have added a new experimental extension to build all sorts of views using a plain JSON representation. It will eventually allow us to integrate it with the designer and optionally serialize views to JSON or XML rather than code in InitializeComponent.
The Wisej.Web.Ext.ViewBuilder source code is available in our public GitHub extensions repository and on NuGet.
As a simple start, this is what you can do with the ViewBuilder:
In the code above you can see two ways to use the ViewBuilder: as an extension method on any ContainerControl
type (Form, Page, UserControl) to create the child components inside the target control; or as a static method used to create a new view from the model.
You can also see three different input types: Stream, Object, and String:
Stream is any stream that returns a JSON string.
Model is any object of any kind, just like any data object or view model.
String is a JSON string.
In all three cases, the input is an object model that is used to build the view. The code below shows a simple form with a TextBox and a Button:
As you can see in the simple model above, the model is always the same. The representation can be JSON (could be XML or yaml or anything else) or directly a .NET object. These are the most important features to notice:
Lower case field names. The ViewBuilder recognizes lowercase names and resolves them to the correct property. It allows JSON models to follow the JavaScript camel casing convention.
Events are treated like properties. Assigning an handler is the same as calling += or AttachHandler.
Extension properties, like the ToolTip extender", are addressed using the name of the extender component: i.e. "toolTip1.ToolTip". (Note that you don't need to use the ToolTip extender for tooltips, all Wisej.NET controls have the ToolTipText property.)
When declaring a model property, extender properties use the underscore instead of the dot to address the component.
All non-numeric values are in strings. Including Point, Size, Color, Font, etc. The ViewBuilder uses the property's TypeConverter to parse the string.
The object model is simply the same model as the target component, with just one system property: _type
. Use "_type" to define the class of the component to create. It can be a fully qualified type name or a simple name. If it's a single string, Wisej.NET will search in the Wisej.Web.
namespace first.
For the _type value, you may also use a fully assembly-qualified type name. It allows your view models to refer to external assemblies and load them dynamically when the ViewBuilder creates the view.
Collections are assigned as arrays. The ViewBuilder detects what kind of collection is expected on the target and either assigns an array or calls the collection's AddRange method.
Use the components
collection at the root level of the top-level container to add Wisej.NET components and extenders: Animation, ToolTip, ErrorProvider, etc.
The ViewBuilder can also resolve references to other components in the same container by name. If you set a property that expects another component, for example, ContextMenu, or DropDownControl, you can use the name of the component or control in any location of the model.
The ViewBuilder will search for the component or control name at all levels and assign the reference to the property.
Wisej.NET supports the IExtenderProperty system at design time. Now it supports it also in this new ViewBuilder model. There are usually two kinds of extenders: a component and a container.
For example, when you drop a control in a TableLayoutPanel, you will notice that the control has "gained" new properties at design time: Column, Row, RowSpan, ColumnSpan, and others.
The ViewBuilder model fully supports both, extender properties defined by another component and extender properties directly on the container.
In the JSON sample above you can see that button1 sets properties it doesn't have: columnSpan, column and row. These properties are extender properties provided by its TableLayoutContainer.
It also sets two more properties it doesn't have: animation1.name and animation1.event. These properties are provided by the animation1 component declared in the components collection.
Data binding is also fully supported. We used a syntax similar to WPF or MAUI. Any property in the model can be assigned a string that starts with "{Binding"
to become a data-bound property.
The complete syntax is:
"{Binding Name, Source=Source, Format=Format, OnParse=OnParseHandler, OnFormat=OnFormatHandler, SourceUpdateMode=SourceUpdateMode, ControlUpdateMode=ControlUpdateMode}"
Everything is optional except Name.
If the Source is not specified, the current container (this or Me) is assumed to be the source. When the Source is specified, it's also relative to this or Me, unless it's a reference to a component, a BindingSource, for example.
Data binding and parsing is a large and complex system. This is probably one of the areas on the ViewBuilder that will evolve the most in the next builds.
Attach handlers to any event by name. You can refer to static methods using their name or fully qualified type name, or you can attach to local methods simply by name or using this or Me.
Event handlers are resolved through the ViewBuilder.ResolveEventHandler
function , which is overridable. The default resolver looks up the method and returns its MethodInfo object.
You may also create your own, and attach to JavaScript handlers or compile the code on the fly!
Your ResolveEventHandler
implementation (see Custom Resolution) receives the string assigned t the "click" event and it's up to you to return the MethodInfo to attach to the event.
The ViewBuilder class exposes two assignable methods: ResolveReference and ResolveEventHandler:
It's invoked when the ViewBuiler needs to convert a string name to a reference to a component or a control. If you assign your resolver to this method then it's entirely up to your code to resolve those references.
It's invoked when the ViewBuilder needs to convert a string to a MethodInfo reference in order to create a delegate and attach to the event.
If you assign your resolver to this method, then it's entirely up to your code to convert the string to a method. This handler allows you to attach any kind of handler, event one you build on the fly, to any event on any control created by the ViewBuilder.
When enabled, Wisej.NET will show the Edge renderer(s) it uses to display each control in the pixel-perfect design view.
You will see one or more small windows that show the renderers managed by the design view. When debugging the client side JavaScript, we recommend setting the Parallel Renderers to 1 - it's much easier to have only one Developer-Tools window open.
Click anywhere on the renderer window and press F12 to open the Developer Tools window.
With the Developer Tools open you can fully debug everything the designer renderer does on the JavaScript side. In Visual Studio you will also see the same debug view displayed in Chrome or Edge when showing the developer tools.
Using this powerful features allows widget developers to debug and test their JavaScript implementation at design time.
Yes.
There are two sets of templates available in Wisej 3.
One set of templates uses Wisej 3 with the old template style. This template format allows you to use IIS Express and Local IIS normally.
The templates based on the new SDK-Project format are more complicated.
Running a project in the new SDK Project format that is set to .NET Framework will start with IIS Express. Running a project in this format that targets .NET 6+ will use Kestrel.
No. Wisej 3 was designed for .NET 5+.
Yes.
Yes, but you will lose access to the designer.
All Wisej projects must target .NET Framework v4.8 to use the designer.
Yes but you have to create the docker file. We only provide a basic docker file for Ubuntu.
Yes. We provide a basic docker file for Ubuntu.
Yes, unlike standard ASP.NET Core projects, which have dropped VB.NET, Wisej features VB.NET templates for .NET 6.
There is no need to change the project format if you are staying with .NET 4.8! Wisej 3 supports both .NET Framework and .NET Core. You only need to change the project format to the SDK format if you are going to use .NET Core and ASP.NET Core.
When migrating a Wisej 2.x project to Wisej 3, it's not recommended to change the existing project but rather create a new Wisej project using the new templates and copy over files.
Moving from older versions of Wisej to Wisej 3 requires updating the project to the new SDK Project format.
Take note of all embedded resources, references and build customizations within the Project.
Unload the Project.
Delete the content of the .csproj file.
Copy the following text into the .csproj file.
5. Reload the Project
6. Add embedded resources, references, and build customizations back.
Files that are Embedded Resources are reset to Content, don't forget to set them again to Embedded Resource.
All the localization .resx files need to be upgraded to Wisej.Framework, Version=3.0.0.0. It's a simple task that can be completed using Visual Studio Search & Replace.
Replace "Wisej.Framework, Version=2.0.0.0" with "Wisej.Framework, Version=3.0.0.0".
It's likely that your projects don't have any Wisej.Framework reference in the .resx files.
A Startup.cs file is required for ASP.NET Core projects (Wisej projects targeting .NET 6+).
Right-Click the Project.
Click Add > Class.
Set the name to Startup.cs.
Click Add.
Copy the following content into the Startup.cs file or download the file below.
Don't forget to update the Namespace.
Wisej 3 projects targeted for .NET 6+ require adding a launchSettings.json file to the /Properties directory of the project.
Click Add > New Item > JSON File.
Name the file launchSettings.json.
Copy the following text into the file.
Profiles define the startup behavior for the application. Don't forget to update the profile names.
The new SDK project format has many properties that are not available in the project property panel. You have to get used to editing the .csproj or .vbproj files directly.
Unfortunately, there isn't a comprehensive list anywhere and many properties are not standard and depend on build targets. All you can do is search around...
These are just a few that we have added to our templates:
Wisej.NET 3.1 enhances the milestone 3.0 release by adding several new unique features and a simplified installation procedure.
In addition to numerous bug fixes and considerable performance enhancements to our libraries, 3.1 includes the following notable new features:
A basic but very useful Typed TextBox is one of the most desired features in practically all web development platforms and is now available in our toolkit
You can use this new editor control to define the type of Value property to which the text should be parsed, a.NET format string (standard or custom), and whether the formatted string should be preserved when editing or removed when entering the editor.
You can also take over the parsing and formatting using the new events and virtual methods.
New "Tiny Tool Icons" have been added to the Property Editor in the designer to indicate some of their attributes or reset New their value.
These new icons may save time for developers by providing information and features that needed several clicks to reach.
Reset. Instead of having to right-click and select the Reset option (if enabled), this tiny tool allows developers to reset the value of a modified property with a single click.
Data Bound. Indicates that a property is data-bound. This information was only available by opening the data binding dialog.
Localizable. Indicates that the property can be localized. Previously, this information was unavailable without inspecting the source code or attempting to localize the value.
Responsive. Indicates that the property is a Responsive Property and can hold multiple values associated with client profiles.
The new property ListBox.Orientation changes the layout of the items in the ListBox from the standard Vertical layout to the new Horizontal Flow layout.
Everything else remains the same, including horizontal scrolling, keyboard selection, and so on.
Using the Visual Studio Marketplace allows us to provide new project and item templates. You can use the Visual Studio Extension Manager to install our new templates and automatically register them within Visual Studio.
When Wisej.NET is installed from the VSIX installer (Visual Studio Market Place or downloaded from our builds page), you can press F1 to get directed to our extensive online documentation.
The system can determine the Wisej.NET class, property, or method by the location of the cursor in the editor. This has support for the main API and all the extensions!
Our Wisej.NET extension helps in several ways like scrolling widgets into View, handling Tree Views, Keystrokes, counting Alert or Message Boxes, and much more.
We have added a new module to our open-source toolkit. The new extension employs the Web Authentication API (known as WebAuthn).
This is a new experimental feature. We added a new Application.OpenWindow(url, ...) method with an optional onclose callback action, and added new onclose callback action to the existing Application.Navigate() method.
It can be used for several purposes:
Dispose a resource (i.e. delete a file or close a handle) when the user closes the tab or the popup.
Simulate detaching a specific window from the browser and allow the web application to work with multiple monitors.
The same effect can be achieve using a browser tab that the user can detach and move to a second monitor.
Wisej.NET 3 is the first release of Wisej that supports both .NET Framework (4.8) and .NET Core (now .NET 6, will be 7...) and runs on Windows, Linux and MacOS.
Wisej.NET 3 for .NET Framework 4.8 replaces Wisej 2.5 while Wisej.NET 3 for .NET Core 6 is a new build for ASP.NET Core applications that can run on Windows, Linux and MacOS.
Adding support for .NET Core and ASP.NET Core required changes to the HTTP/WebSocket layer and the implementation of a new Wisej Middleware module. Everything else is fundamentally unchanged or enhanced: .NET Controls, JavaScript Widgets, Designer, Themes, Theme Builder.
We have been using Wisej.NET 3 on Linux internally on many test projects and we have run it on several Linux distributions as well as small devices like the Raspberry Pi for over a year. And we are in the process of testing it on even smaller embedded devices running custom Linux builds.
New projects can target multiple .NET platforms. When you create a new Wisej 3 project, our wizard will allow you to select the target and enable certain options:
You can edit the .csproj or .vbproj at any time and change the <TargetFrameworks> tag. Just make sure that "net48" is always the first, if you want to use the designer.
Now that Wisej applications can run on .NET 6+ they are standard ASP.NET Core applications. When running on .NET 4.8 they are standard ASP.NET applications.
ASP.NET Core applications don't use System.Web anymore and are not integrated with the IIS pipeline. They are all based on OWIN and Microsoft's Kestrel. Which means that they are almost always self-hosted web applications.
Wisej supported the OWIN middleware approach since 1.5, based on Microsoft's Katana.
This is how you add Wisej to a standard ASP.NET Core application:
All ASP.NET pages and all ASP.NET controls will NOT work on ASP.NET Core.
While the vast majority of the work in Wisej 3 has been to split the code between .NET Core and .NET Framework, replacing all of the ASP.NET code with ASP.NET Core, we have also added some cool new features.
This is a powerful new feature that allows an additional level of control that was not possible before.
If you just need to apply a specific layout, or a combination of layouts, by code, without having to change containers, use the Control.LayoutChildren() methods:
LayoutChildren(controls, dock, viewArea, spacing, useMargins, hAlign, vAlign)
LayoutChildren(controls, direction, viewArea, spacing, useMargins, hAlign, vAlign)
Each method is overloaded with multiple variants and most parameters are optional using predefined values.
You can call this method as many times as you need and with as many combinations of rules as you like. It doesn't change the layout engine or the layout options, it only moves and resizes the child controls according to the specified arguments.
This new feature is still experimental and may change in future builds.
Added new interfaces that allow code to use common features across controls:
Using these interfaces eliminates the need to cast a control to the specific class.
Wisej 3 adds a new experimental feature to support the dependency injection model natively.
Using this new feature is quite simple, flexible and very powerful. Use Application.AddService() to register a service and Application.GetService() to retrieve it. Services can be added with several scopes:
Global. Only one instance (singleton) is shared among all sessions.
Session. Each session gets its own instance.
Transient. Each request gets a new instance.
When the services instance passed to AddService is null, Wisej will automatically try to instantiate the service class on first use (on demand). As soon as the service goes out of scope, Wisej will automatically dispose of it. If the service implements the IDisposable interface, it gets a call to IDisposable.Dispose()
A service can also be instantiated on demand in a callback.
Using the service is also quite simple. Regardless of the scope, the service consumer simply calls:
The return is just null if the requested service is unavailable.
Shows like this when the grid is empty.
Rolled up all bug fixes.
Layout speed improvements on the client and server.
Refreshed all icons in designer and Theme Builder.
On a separate Label (which now implements the IErrorProvider interface). The Label is automatically show or hidden.
Field | Description | Example |
---|---|---|
Wisej 3 introduces a new approach for creating and working with projects based on ASP.NET Core. The changes include a new , Kestrel Web Server, and more.
Right-Click the project on the \Properties folder .
= false
= true
= false (.NET Framework)
= bin/ (.NET Framework)
Wisej.NET is now easier to use than ever before. It is available as a VSIX installer through the or via the Visual Studio Extension Manager. Without using the GAC, the new VSIX installer automatically registers Application Templates and the Wisej.NET designer.
Previously, the data binding system in Wisej.NET only supported the class for advanced data binding. However, MAUI and WPF support the simpler type for their data binding.
Now Wisej.NET seamlessly supports both. Support for the is identical in all data binding implementations.
Together with the support introduced as an experimental feature in 3.0, it now supports most 3-letter or 4-letter binding models.
The implementation introduced with 3.0 is now fully supported.
are now first-class citizens in Wisej.NET 3.1.
We have moved the and added new similar to the Blazor startup templates.
We have selected new automation tools as we built our new automated test suite, which we’ve decided to share using , an end-to-end automation solution for Web and Mobile apps with all the latest browser drivers.
The extension enables developers to add external and platform-specific authenticators into Wisej.NET applications. You can read more about the new extension in our blog post .
Application.OpenWindow() opens the url in a new . If you specify the onclose callback method, it is invoked when the user closes the popup window.
Existing Wisej 2 applications should be able to run on Wisej.NET 3 mostly unchanged. Hopefully, all you need to is the Visual Studio to the new "Sdk" project format.
The is not available for the .NET Core targets and relies on the dual target approach, with the added benefit that Wisej applications can be deployed on .NET Framework 4.8 on Windows and .NET Core on Windows, Linux and MacOS.
The new Sdk project format has many properties that are not available in the project property panel. You'll have to get comfortable editing the .csproj or .vbproj files directly. See for an example if the ones we added to our templates.
Multitargeting will inevitably require the use of conditional compilation and excluding certain source code files from some platforms. In our sources we use and partial classes to neatly separate code keeping the same class structure.
All the , and methods have a new optional argument: a callback function, invoked when the file has been downloaded by the client.
Wisej supports all sorts of very powerful (impossible to achieve with any other web platform). However, all the layouts are implemented in layout engines and are "permanent": you have to set layout properties for the children and the container manages the layout using the specific layout engine.
Calling LayoutChildren without the controls collection and without the viewArea argument, arranges all the direct children using the control's as the bounding area.
Otherwise you can specify only a subset of the child controls and define a view area to limit the layout space. You can also try this new automatic layout functionality at design time using the new .
We have introduced a new experimental feature to extend the current data binding model to make it compatible with MAUI's approach. In our implementation, commands work seamlessly with the existing data binding and have access to the full of the . In MAUI the command's code is limited to a single parameter.
In this first implementation, and have a new property and event. The Command property can be data-bound to properties of the data source.
When returns false, the command source button automatically disables itself. Clicking the button invokes the method attached to the command.
Use the new class or Command<T> class to wrap the implementation of a command and to cast the data item coming from the data source.
. Implemented by all controls that have the Label property.
. Implemented by all controls that have the various Image (ImageIndex, ImageKey, ImageSource) properties.
. Implemented by all controls that have the ReadOnly property.
. Implemented by all controls that have the Modified property.
The Application class now is an and has two new methods to manage services: and with several overloads.
Our control can handle an unlimited number of rows thanks to its built-in virtual scrolling and page caching on the client side. As the user scrolls the rows, the control manages a client-side cache of pages or rows and requests from the server only the pages that are needed to render the current view.
You can control the size of the client-side cache using the BlockSize and MaxCachedBlocks properties. When the is in , it doesn't hold any data and can manage any number of rows with minimal memory usage. Your code provides the data as needed handling the and events.
However, the events are fired every single time the application code uses a cell in the grid (in the grid doesn't hold any data). Usually, implementations of a virtual DataGridView must implement some kind of cache management on the server.
The new event makes this task a lot easier. It is fired when the client requests a page allowing an application to build and manage a small server-side cache in sync with the client scrolling, resulting in a much simpler usage of the events.
This property has been as an experimental feature for a while and it's now a supported property. It takes an HTML string and it displays filling the entire grid space when there grid contains no rows.
Name
Name of the property in the data source to bind to.
{Binding UserName} {Binding Company.Name}
Source
Reference to the data source. Can be any object in the current context (this) or a component in the components collection.
{Binding Name, Sorce=DataContext} {Binding CompanyName, Source=bindingSource1}
Format
Any standard or custom .NET format string.
{Binding Amount, Format=Total: c}
OnParseHandler
An event handler for the Binding.Parse event.
{Binding Location, OnParse=ParseLocation}
OnFormatHandler
An event handler for the Binding.Format event.
{Binding FullName, OnFormat=FullNameFormat}
SourceUpdateMode
One of the DataSourceUpdateMode fields.
{Binding Name, SourceUpdateMode=Never}
ControlUpdateMode
One of the ControlUpdateMode fields.
{Binding Name, ControlUpdateMode=Never}
When building class libraries that target .NET 6+, the assemblies that are referenced via NuGet will not be copied to the bin folder unless the following element is added to the library's csproj file:
All referenced assemblies should be copied automatically in .NET Framework.
If a project or assembly reference is not used in the main Wisej project, the referenced project's dependencies will not be loaded into the App Domain automatically.
In .NET Framework, any assembly referenced by the main Wisej project would have it's dependencies loaded into the App Domain.
For example:
If you create a custom control library that implements a custom Bubbles notification that gets dynamically injected into the main Wisej project, you will need to call Application.LoadAssembly() on Wisej.Web.Ext.Bubbles to load the custom library's dependency into the Wisej project.
The Visual Studio designer in Wisej 3 has been upgraded to support Visual Studio 2022. Everything else is unchanged, and it requires the .NET Framework 4.8 target to work with Visual Studio.
Wisej 3 components are available in the toolbox under the "Wisej 3" tab name. Since Wisej 2.5 we have stopped installing components in the toolbox and instead rely on the automatic installation of nuget components.
Unfortunately Visual Studio still doesn't support toolbox icons for nuget components. You can always install a custom tab and drag & drop /net48/Wisej.Framework.dll to the toolbox to see the icons. Don't use "Wisej 3" for the tab name or nuget will replace your toolbox content.
Extensions added to a project using the NuGet Package manager will show up under the "Wisej 3 Extension" tab name.
If the toolbox doesn't show the Wisej tab and tools, make sure that the Automatically Populate Toolbox option is set to true.
Beginning with Wisej 3, projects will be able to target multiple frameworks.
To add multiple targets to your Wisej application, ensure the project uses the SDK-Project format and add the following tag.
net48 must always come first in the csproj file to load the Wisej designer.
You use four preprocessor directives to control conditional compilation:
#if
: Opens a conditional compilation, where code is compiled only if the specified symbol is defined.
#elif
: Closes the preceding conditional compilation and opens a new conditional compilation based on if the specified symbol is defined.
#else
: Closes the preceding conditional compilation and opens a new conditional compilation if the previous specified symbol isn't defined.
#endif
: Closes the preceding conditional compilation.
When the C# compiler finds an #if
directive, followed eventually by an #endif
directive, it compiles the code between the directives only if the specified symbol is defined. Unlike C and C++, you can't assign a numeric value to a symbol. The #if
statement in C# is Boolean and only tests whether the symbol has been defined or not. For example:
Multitargeting will inevitably require the use of conditional compilation and excluding certain source code files from some platforms.
In our sources we used Shared Projects and conditional property groups in the project file to compile "net48/Test.cs" only on .NET 4.8 and "net6.0/Test.cs" only on .NET 6.
If you combine this technique with partial classes you can build very flexible classes that have code that compiles on different platforms:
Visual Studio will show you which targets apply for each file on a drop down at the top left.
Once your main project targets multiple frameworks, all the projects and the libraries it references must also provide their binaries for multiple targets.
This is all done automatically as long as the referenced projects build the binaries using the standard .NET naming convention, and libraries are added using NuGet packages that provide their binaries for multiple targets.
If you use a package only for .NET 6 or only for .NET 4.8 it will still work but you have to exclude the code in the target framework that cannot use the package.
Wisej 2.5 requires .NET Framework 4.8. This is the last supported .NET version from Microsoft. Wisej 3 will target both .NET Framework 4.8 and .NET Core 5, 6, 7, …
Wisej 2.5 can use the latest Edge/Chrome in the designer, introducing the following features:
Multiple parallel rendering engines
Use widgets based on the latest ES6 ECMAScript
Use JavaScript arrow functions
Accurate SVG positioning
Faster rendering
Visual Studio 2022 64bit
Always make sure that you have the latest WebView2 SDK installer from:
Learn more about WebView2 here:
Theme Builder now can use the latest Edge/Chrome browser to show the preview controls and to run your applications while working on the theme.
As an added bonus, now you can detach the browser tab and work with your application running on a separate window while working on the theme at the same time!
This powerful addition allows you to aggregate and style rows using the standard functions or any custom formula you may need in your code. Aggregated rows are added either above the group, below the group, or can become parent rows in a hierarchical structure.
Wisej 2.5 consolidates several enhancements and bug fixes:
JavaScript Optimization. We have removed all the JavaScript code that could cause the V8 engine to recompile a class improving client side speed.
CharacterCasing Property. All controls that show a text (i.e. Label, Button, MenuItem, ...) have a new CharacterCasing property allowing an app to change the case if the text without having to alter the code.
Design Rendering speed. Several improvements and the new parallel renderers improve the designer experience.
New Bootstrap Theme. We have added a new bootstrap theme and the full bootstrap icon-set in a new Wisej Icon Pack.
This is a major change in the way we deploy Wisej and it prepares for the next major Wisej 3 release with support for dual framework targeting and .NET 6+.
Wisej.Framework.dll will be installed in a local NuGet repository at %ProgramFiles%/IceTeaGroup/Wisej 2.5/nuget as a NuGet package named "Wisej Local". It will not be copied to $ProgramFiles%/IceTeaGroup/Wisej 2.5/bin anymore.
This change will allow developers to switch to any Wisej version without having to run the installer again, or uninstalling and reinstalling. Simply open the NuGet Package Manager and select either "Wisej Local" or nuget.org and filter for "Wisej-2".
The new templates and existing projects will have to use the NuGet Package Manager to reference Wisej 2.5. This is important because it will allow Wisej 3 to deploy the Wisej.Framework assembly for multiple targets.
All the extensions will only be available at NuGet.org.
In order to use the new <PackageReference> syntax in your .csproj or .vbproj project files, instead of the old Packages.config file, make sure this option in Visual Studio is set to PackageReference:
Starting with Wisej 2.5 you will not find the Wisej components in the toolbox in Visual Studio like before. We have stopped installing the toolbox and instead rely on NuGet and Visual Studio automatic population of the toolbox.
Make sure that your Visual Studio has the "Automatically Populate Toolbox" feature turned on.
This change eliminates the common problem of the Wisej toolbox disappearing, allows us to add Wisej to multiple version of Visual Studio installed on the same machine, and gives us the flexibility to add and publish extensions more frequently.
A downside is that Microsoft still doesn't support toolbox icons for NuGet packages. If you really want to add Wisej Components with their icon to the toolbox, follow these steps:
Add a new tab to the toolbox and name it "Wisej" (don't name it Wisej 2.5 or it will be replaced by the NuGet Package).
Locate the Wisej.Framework.dll (or extension dll) and simply drag & drop it on the new toolbox tab.
Wisej is not limited to C# or VB.NET! We have tested it with other .NET languages and made sure it works also with COBOL, x# (CLIPPER, dBase, Vulcan.NET) and F#.
MicroFocus VisualCOBOL, NetCOBOL, Raincode COBOL can build single-page web apps with Wisej!
CLIPPER, dBase, Vulcan.NET, XSharp can build single-page web apps with Wisej!
Wisej 2.5 improves the designer experience using the new Edge/Chrome engine to render the pages at design time in Visual Studio, simplifies the deployment of the growing list of Wisej Extensions, and completes the control with powerful new features.
Wisej 2.5 is deployed as a local and online NuGet. It will not be in the /bin folder in Program Files anymore. See .
The control now integrates and expands the SummaryRows extensions, and fully implements the frozen rows feature.
Finally the supports frozen rows, including frozen cells spanning multiple rows.
Wisej 2.5 adds support for frozen rows at the top of the DataGridView, including support for and to allow a cell to display its content across rows and columns.
Make sure your Visual Studio is configured to use the latest NuGet syntax in .csproj or .vbproj. See .
To add an extension simply select the package and it will be automatically downloaded and installed on your development machine. All it's components will also be automatically added to the .
A Docker container image is a lightweight, standalone, executable package of software that includes everything needed to run an application: code, runtime, system tools, system libraries and settings.
Using Visual Studio Docker Tools, Wisej 3 applications can be packaged and run in these containers.
When creating a cross-platform Wisej 3 application, Visual Studio will prompt the user to add Docker support to the project.
To run the Wisej application in a Docker container, change the runtime target to Docker.
When building and running a Docker project, the first TargetFramework is always used. If Docker can't run the first TargetFramework, it will target the second or third listed framework.
Docker can build images automatically by reading the instructions from a Dockerfile
. A Dockerfile
is a text document that contains all the commands a user could call on the command line to assemble an image. Using docker build
users can create an automated build that executes several command-line instructions in succession.
Below is a sample Dockerfile configured to run a Wisej 3 application that targets .NET 5.
Be sure to update the Dockerfile if the TargetFramework is not .NET5.0.
Wisej 2.1 consolidates several new features from 2.0, while adding several new controls (including a powerful new DataRepeater) and reaches a high level of stability.
The new DataRepeater container is a sort of a custom data grid. Instead of rows it repeats a template panel containing child controls in any layout. Child controls are automatically data-bound to the current record.
The infrastructure is virtual, which means that the DataRepeater only creates the visible panels and updates the controls as the user scrolls them into view, allowing the management of an unlimited numbers of records.
It can scroll its items vertically or horizontally, supports touch scrolling, can hide the scrollbar, and it can adapt to the user's device layout. You can use the DataRepeater to build data-bound lists of any kind for mobile or desktop devices.
All editors have a new Label property. It adds a responsive, localizable and themeable label next to the editor.
The Label supports 5 positions: top, left, bottom, right and inside (this is the material style that shrinks the label when there is content).
The size of the inner label and the inner editor can be set to proportional, fixed, or auto-sized. All the properties can automatically change according to the device profile (e.g. the label can be on top for mobile devices, and on the left for the desktop). Supports mnemonics focus, colors, and many other features.
This is a new simple time editor, based on the UpDownBase class.
This is a new editor similar to the existing DomainUpDown and NumericUpDown. Handles a TimeSpan value in different localized formats. Supports minimum and maximum values, it’s bindable, nullable, and supports the quick increase of the time part under the cursor using the arrow keys.
It is an all-purpose shape control that can represent simple shapes with different styles.
Use the Shape control to frame content, including images, and to handle the four borders of a plain DIV tag. It lets you rotate the item, display circles, ovals, rectangles, and triangles using a simple data-bindable all-purpose control.
You can place it behind the controls to frame, or use it as a container and place the controls inside.
This new extender component (drop it on a design surface to use it) adds a new property TabOrder to all containers. If your page or form contains other containers (i.e. Panel, GroupBox) each one can manage the tab order of its children independently.
Supports 3 options: Default, AcrossFirst and DownFirst. Once set, the TabIndex of all the children is set automatically, and it’s updated automatically when adding or removing children.
We have changed all the static events exposed by the Application class to weak events. This new approach (also present in the WPF platform) prevents the source of the static event from holding on the instance handler. It will prevent applications from accidentally leaking memory when attaching to static events exposed by Wisej.
All controls that supports the VirtualScroll mode (TreeView, ComboBox, ListBox, ListView and DataRepeater) now have a new PrefetchItems property allowing the pre-loading of a items outside of the visible area to support smoother scrolling.
This is a new configuration option in Default.json (sessionStorage: "local" | "session", the default is "session"). It allows the Wisej application to select the browser's local storage ("local") to store the session id. When coupled with a longer or unlimited session timeout allows a user to reopen the browser, or the Wisej desktop executable, and find their work exactly where they left it.
This is a new configuration option in Default.json. When set to true, it allows the server application to impersonate the user's Windows credentials on the server (e.g. access the DataBase, the File System, other services, etc.).
We have added a simple new feature to play system and custom sounds.
This new feature allows your application to modify any Wisej theme at runtime by code. You can create themes on the fly for each specific user, or modify the global theme (shared by all users).
Example: Create a new there only for the current user by cloning the current theme and changing the background color of buttons.
Example: Modify the current theme. If it is a shared theme (from the /Themes folder), the change will affect all users.
You may also save the newly created theme to /Themes to make it available to all users through Application.LoadTheme(name).
Wisej 2.2 introduces built-in PWA support, dynamic integration with all major JavaScript vendors, native iOS and Android integration (available for Technology Partners), enhancements to all controls, improved memory management, and lots of new functionality across the board.
Progressive Web Application (PWA) support is now built-in into Wisej. It allows a Wisej application to be installed in the desktop or a mobile device along with the locally cached libraries and offline pages.
A new PWA project template includes a set of professionally-designed offline pages end the required manifest file. The worker process script is embedded in the Wisej loader. Wisej will automatically pre-cache locally all the resources and offline pages. Enable PWA support in Default.json by setting enablePWA: true.
The improved offline detection process automatically switches to the offline pages when it detects a disconnection and restores the application when the connection is restored.
A new event Application.BeforeInstallPrompt allows the application to detect when it can be installed as a PWA, and a new client-side method Wisej.showPWAPrompt() displays the browser's PWA installation prompt. Using the Application.BeforeInstallPrompt event allows the application to display a custom notification to the user (the browser's default PWA notification is just a tiny + symbol in the address bar.)
At this time it appears that only Chrome fires the BeforeInstallPrompt event.
Additionally, the application can attach a client side event to a button or an icon to show the PWA installation prompt when the user clicks the control.
It is not possible to show the installation prompt from a server side event. To show the prompt on a button click, add a client event handler for the "execute" event and call "Wisej.showPWAPrompt()".
When the application goes offline, Wisej loads the /Offline/Default.html page. The image below is one of the pages included with the project template. However, you can put an entire JavaScript application inside the /Offline folder. Wisej will pre-cache locally all the files at all level.
Wisej will switch back to the application as soon as it detects that the connection is restored. Unless the session expired, the entire previous state is reloaded and the user is able to keep working from where the disconnection occurred.
Currently the native integration packages for iOS (Xcode) and Android (Android Studio) are available for free only to Technology Partners. However, we are planning to add new license options to Wisej to make these packages available without having to sign up for the Technology Partner program.
Our integration packages create a hybrid application, where the Wisej web application is able to interact with all native-only features of the mobile device.
The Wisej app can: show native alerts, use the camera, use the microphone, use the GPS, read the magnetometer read the gyroscope, read the accelerometer, play sounds, switch the flashlight, push notifications, read and write NFC chips, authenticate using TouchID or FaceID, create a native Toolbar, create a native TabBar, manage the StatusBar, read all the device information, handle multiple screens, lock the screen orientation, manage the screen brightness, brew coffee, and more…
You can achieve similar functionality for free by using the PhoneGap open source project. In our view, the learning curve is steeper and the functionality offered by PhoneGap is not as powerful as our integration.
For example, this is all the code you need to authenticate a user using FaceID in C# or VB.NET from the server side.
A Wisej hybrid application can also push notifications, read any property of the device, store files locally, and manage a native toolbar, a tabbar, the status bar, and all the available sensors through the Device object.
Wisej 2.2 also greatly improves virtual scrolling and touch integration.
There are two important enhancements in the Wisej.Web.DataGridView control:
Starting from Wisej 2.2, the DataGridView doesn't create any row when the grid is data-bound or running with VirtualMode set to true. It instead gets the values directly from the data source or the CellValueNeeded event when virtual.
A simple test with 100K rows and 10 columns in VirtualMode uses about 5MB in Wisej 2.1 and only about 400KB in Wisej 2.2. It basically only needs 1 Int32 per row to keep track of the state of each row.
As the code requests rows, the framework converts virtual rows into real rows transparently. However, if the application is changed to use dataGrid.GetValue(col, row ) and dataGrid.SetValue(col, row, value) instead of addressing the cells directly, it will read and save from/to the data source and will not create any row.
Now the DataGridView supports all the standard selection modes (CellSelect, FullRowSelect, FullColumnSelect, RowHeaderSelect, NoSelection) and adds a new mode: RowColumnHeaderSelect.
See DataGridViewSelectionMode for a description of each selection mode.
You can use the SelectedCells, SelectedRows and SelectedColumns collection to read the selected objects.
Note that the collections of selected objects depend on the SelectionMode. For example, if the SelectionMode is set to ColumnHeaderSelect, users can select cells or columns. When the user selects a column by clicking on the header, the SelectedColumns collection will return the selected column, but the SelectedCells collection will be empty. However, testing the DataGridViewCell.Selected property of each cell in the selected column will return true.
Wisej 2.2 includes a new and lighter notification control: Wisej.Web.Toast.
Unlike the MessageBox and AlertBox, which are static classes, the Toast is a component that you create and can hold on to in your application. You can reuse it and you can update the content while the Toast is visible.
It can be located in any of the 9 standard locations. By default it appears at the TopCenter location. It contains an icon and a text that can display any HTML content (by setting the AllowHtml property to true).
Toasts auto close by default after 5 seconds but they do not auto dispose. To auto dispose a toast instance when it's closed, set the AutoDispose property to true. You can detect when the user clicks on a Toast by handling the Click event, and handle the Close event to run code when the Toast is closed.Populate a ComboBox without keeping the binding link with the data source.
Now the DataRepeater supports items of variable height (when in vertical mode) and width (when in horizontal mode). It can auto size the child items to fit the content, or you can set the size of each item programmatically.
Additionally, the virtual scrolling, mobile scrolling, and prefetching have been improved considerably. The DataRepeater can now handle unlimited items seamlessly without a glitch.
Applications using the DataRepeater can set the AutoSize property of the panel template to true to automatically resize each item panel to fit its content, or you can set the height or width of each item while handling the ItemUpdate event
All controls that support data binding have been improved with two new methods:
Fill
Populates the control from a data source object without keeping the control linked to the data source.
Append
Appends the data source object to a previously populated control without keeping the control linked to the data source.
These new methods allow a control to retrieve the data from the data source without keeping the bidirectional binding link. All the properties that specify the fields to bind to are still used, making the population of list controls much easier.
Wisej 2.2 also adds full data binding support to the ListView control, including support for the new Fill and Append methods.
The new ListView control supports the following data binding properties:
DataSource
Returns or sets the data source for the ListView control.
DataMember
Returns or sets the name of the list or table in the data source for which the ListView is displaying data.
ColumnHeader.DisplayPropertyName
Returns or sets the property to display in the ListView items.
ListViewItem.DataBoundItem
Returns the data-bound object for the ListViewItem.
The DisplayPropertyName property can only be set on column headers in order to be able to data bind items and sub-items.
All the premium integration libraries are now free. Each library is a GitHub ongoing project. The libraries for Wisej 2.1 include some extra dynamic code that is not built-in the Wisej.Web.Widget class in Wisej 2.2.
The Wisej.Web.Widget class exposes a new Instance property. It's a dynamic object that is able to convert any method call into a JavaScript call on the third-party widget and can attach custom event handler to events fired by the implementation.
You must buy a license directly from the vendor of the widget library. Wisej doesn't include any free license!
The ComboBox and the ListBox control have a new LazyLoading property, similar to the existing TreeNode.LazyLoading.
When LazyLoading is set to true, the list items (or child nodes in a TreeNode) are sent to the client the first time the ComboBox is dropped down, or when the ListBox "appears" on the client browser. It reduces the size of the data sent to the browser when creating a page and speeds up the initial loading of pages and windows.
All controls in Wisej 2.2 have some enhancement:
Control.ToolTipText
All controls have a new ToolTipText property. It allows an application to set the tooltip text on any control without having to add the Wisej.Web.ToolTip provider.
However, if the application needs to modify some additional aspects of tooltips, it should still use the Wisej.Web.ToolTip provider which exposes the additional tooltip properties.
PictureBox.Filter
Sets a CSS filter on the PictureBox image.
TabControl.ScrollStep
Sets the number of pixels to scroll when the scroll buttons are pressed to bring a tab into view.
ListBox.IncrementalSelection
When true (default) the ListBox caches keystrokes for less than a second allowing a user to type and incrementally select the list items, i.e. typing "ab" selects the first item that start with "ab". When false, typing "ab" will select the first item that starts with "b".
TextBoxBase.SelectOnEnter, ComboBox.SelectOnEnter, DateTimePicker.SelectOnEnter, UpDownBase.SelectOnEnter
When SelectOnEnter is true, the entire content in the editable area is always selected when the control gains the focus.
TreeView.RighClickSelection, ListBox.RightClickSelection
When true, right clicking a TreeNode or a ListBox item (i.e. to show a ContextMenu) will select the item.
TagTextBox.KeepWatermark
When true, the TagTextBox keeps showing the Watermark text in the editable portion of the control after the tags.
DataGridView.SelectionDelay
When set to a value greater than 0 (the default), the grid waits the specified number of milliseconds before notifying the server that the selected element has been changed using the keyboard.
This property prevents the server from being flooded with row selection events when a user rapidly navigates and selects different rows using the up/down keys.
FileDialog.LoadPath, FolderBrowserDialog.LoadPath
The file and folder dialogs expose a new LoadPath event. It is fired for each file and each folder loaded by the dialogs. An application can handle this event and set the icon to display, the size, and the dates related to the file or folder. The event is cancelable, allowing the handler to set e.Cancel to true to filter out specific files or folders from the list.
Application.SetSessionTImeout
Changes the session timeout for the current session only.
The Application object exposes two new global events:
ActiveWindowChanged
This event is fired when the active floating window changes. Allows an application to react to the change of the active window globally.
FocusedControlChanged
This even is fired when the focused control changes, regardless of where it's located. Allows an application to process changes to the currently focused control.
There are two new settings that are supported in the Default.json configuration file:
threadPool
ThreadPool is a map defined as {minWorkerThreads, minCompletionPortThreads, maxWorkedThreads, maxCompletionPortThreads} that corresponds to the system's ThreadPool settings that can be applied by code or in machine.config. See ThreadPool.SetMinThreads. All properties are optionals. A typical settings is "threadPool":{minWorkerThreads: 100}.
enablePWA
Enables PWA support. When set to true, the Wisej bootstrapper will include the built-in service worker. It will preload and cache locally the Wisej libraries and all the assets found in the /Offline directory.
Upgrading from Wisej.NET 1.X to recent Wisej.NET versions is extremely easy. All you need to do is replace the references and make sure some "using" statements referring to design-time features are updated.
Set target .NET Framework to 4.8
Setting the target .NET Framework to 4.8 is crucial to avoid any issues when installing or compiling your application
Replace project references to Wisej.Web.dll and Wisej.Core.dll with a NuGet Package reference
For Wisej.NET 2.X make sure to use the "Wisej-2" NuGet Package.
For Wisej.NET 3.X make sure to use the "Wisej-3" NuGet Package.
Replace .resx namespaces to Wisej.Web. and Wisej.Core. with Wisej.Framework. You can do that by doing a mass replacement. From Visual Studio, go to Edit > Find and Replace > Replace in Files or simply use the Ctrl+Shift+H Hotkey.
Make sure to edit the File types field to only include RESX files.
Change using Wisej.Core.Design to using Wisej.Design using the same process as the previous step, although this time change the File type from RESX files to CS files.
Change calls from ApplicationBase. to Application, again following the same process as the previous step.
Modify Web.config and replace "Wisej.Core" with "Wisej.Framework"
There is no need to change the project format if you are staying with .NET 4.8! Wisej 3 supports both .NET Framework and .NET Core. You only need to change the project format to the SDK format if you are going to use .NET Core and ASP.NET Core.
Starting with Wisej.NET 3.0, we're now shipping the Designer and Templates as VSIX installers. This gives you the ability to manage updates directly from Visual Studio's Extension Manager.
For Wisej.NET 2.X , you can install the designer as its own NuGet Package.
Wisej 2.0 includes a number of powerful new features that can enhance developers productivity, simplify deployment, customize browser widgets, implement responsive design, and speed up server communications.
The new designer adds custom ruler snap lines that can be user defined and saved with the container.
You can select the glyph color and take screenshots of your screens in design mode.
In addition to the action selector you can now also directly setup anchoring by using the arrow buttons.
You can create an infinite number of vertical or horizontal snap lines for your containers.
Just click on the appropriate ruler position.
Snap lines are saved with each container so they are reloaded the next time you design it.
This new button in the designer toolbar gives you a quick overview and access to all objects.
ResponsiveProperties and corresponding profiles simplify Responsive Design a lot.
Wisej now supports many more client-side properties and methods on all controls. It makes it much easier to customize Wisej widgets from server-side code.
AutoShowLoader
Buttons and MenuItems have a new property AutoShowLoader that automatically shows the loader when the widget is clicked - this is a client side event - and removes the loader when the processing on the server is completed.
It is intended to be used on actions that typically require some time to complete and should give the user immediate feedback, i.e. a login button.
CssClass
Sets custom css class names to the widget. You can also manage the css class names using these methods: AddCssClass, HasCssClass, and RemoveCssClass.
States
Sets a custom array of states that can be used in a custom theme or theme mixin. You can also manage the list of states using these methods: AddState, HasState, and RemoveState.
ClientEvents
Collection of client-side events and JavaScriot event handlers that you can set from the server. You can use the collection directly or use these methods now available to all controls: AddClientEventListener, RemoveClientEventListener, and HasClientEventListener.
InitScript
Sets a custom script that Wisej will execute in the context of the widget when it is first created in the browser.
CssStyle
Sets a custom css style string that is assigned to the widget.
Wisej already compresses all traffic packages (HTTP and WebSockets) above a certain threshold by default.
We now switched from GZIP compression to the Brotli compression algorithm.
Our internal tests showed that the compressed response stream is only half the size now.
A Wisej server instance can now decide when to refuse a new session when it receives the first request from the load balance, allowing it to move on to the next instance seamlessly.
This new feature allows the Wisej instance to accept only a certain number of sessions, or to check the memory usage and refuse a request when the memory reaches a certain threshold, or it can use an application-provided function that can refuse the initial request for any reason.
Theme Settings
Stylesheet Rules
Inherited Control
Custom Loader
Replaces the initial loader with one of the new spinners or a custom spinners of your choice.
Brotli
Adds Brotli compression support to the application.
Healthcheck
Vendor | GitHub Repository | Live Demo |
---|---|---|
It's highly recommended that you use the new PackageReference format instead of the old Packages.config file for managing your Packages. Click for more info.
Wisej.NET 3.0 introduced the ability to target .NET 6, with this change came the need to introduce the new .
If you're aiming to migrate to .NET 6 or newer, click for more info.
Templates can also be manually installed, click for more info.
Read more:
Read more: .
See for more information.
Themes now can contain system and value settings. See .
Theme designers now can embed custom css rules directly in theme. This new feature allows for fine tuning a theme and for greater design flexibility. See .
Adds a custom control based on any visual Wisej class. Use it to create you extended controls without having to use the container.
Enables enhanced load balancing support in your application. See .
Syncfusion
DevExtreme
Telerik
Infragistics
Font support has been enhanced in the JavaScript layer as well as the server side .NET layer in Wisej.NET 3.2. Now we support using theme fonts that are not installed on the server and can load all the different variations for a font family.
montserrat-bold.ttf
montserrat-bolditalic.ttf
montserrat-italic.ttf
montserrat-regular.ttf
Wisej.NET will load all the montserrat-*.ttf files in a private Montserrat family and use it at runtime for autosizing and layout calculations.
This new feature is particularly useful when deploying to Azure App Services or other providers that don't allow you to install custom fonts on the servers.
Font sources added to a theme now support specifying the font-style and font-weight properties. It allows a font family in the theme to use different sources (woff, woff2, ttf, etc.) for different styles and weights.
Until now Wisej.NET supported only the "normal" source and let the browser render the different styles and weights.
This is the definition in the theme file:
Note the "version":"1.2.3.4" optional property. It allows the theme to add a custom "version" argument to the source URLs to force reloading the font from a URL that may be cached.
You can also reuse the same .tff files deployed in /Themes/Fonts in the sources for the font definition in the theme or theme mixin.
To support private fonts, simply deploy the .ttf files for the fonts used in the theme that are not installed on the server to the /Themes/Fonts folder. For example, in case your application uses the Montserrat font and it's not installed on the server, put the following files in /Themes/Fonts:
Verify the templates are located in
My Documents\Visual Studio 2022\Templates\Project Templates\Visual C#
My Documents\Visual Studio 2022\Templates\Project Templates\Visual Basic
2. Close all instances of Visual Studio.
3. Run devenv /updateconfiguration
as Administrator in the Developer Command Prompt.
4. Reopen Visual Studio.
Ensure that you are targeting the correct framework. This error will occur when net48 is the first-listed framework in TargetFrameworks. Temporarily switch net48 with your Docker runtime target (net5 / net6).
Ensure that you restore net48 to the first listed framework in TargetFrameworks to load the designer.
Ensure that you are targeting the correct framework. This error will occur when an incorrect framework is loaded into the Docker container. Temporarily switch the first-listed TargetFramework with your Docker runtime target (net5 / net6).
Ensure that you restore net48 to the first listed framework in TargetFrameworks to load the designer.
Occasionally when creating a new Wisej 3 project using .NET48 and .NET6+ the designer will not be visible upon project creation. Rebuild the project and then restart Visual Studio.
The most common designer error is "Unable to cast object of type ‘Wisej.Web.Page’ to type ‘Wisej.Core.IWisejControl’ (or another base type).
This issue occurs when trying to loading multiple versions of Wisej into one Visual Studio instance. Visual Studio loads the Wisej designer assembly for the first page that is shown in the designer. If you open a page from a different project using a different version of Wisej, you will get this error.
Simply restart Visual Studio and re-open the new page.
If the \Wisej 3 directory is missing, run the installer again or download the templates from this .
You may also need to clear the .
Wisej.NET 3.2 adds new enterprise-grade features that simplify the development of complex Line of Business (LOB) cloud applications for the enterprise. Our goal is always to help improve developers productivity and make the applications using Wisej.NET more resilient and maintainable.
The latest Wisej.NET 3.2 is available on NuGet. To use the build, make sure to check the Prereleases option in the NuGet Package Manager.
The Visual Studio 2019 and 2022 extension packages are linked below:
We added a new Validation property extender to provide a modern, centralized, and flexible validation system to Wisej.NET applications.
Once you drop the new Validation component on a container at design time, all the controls are extended with a new property ValidationRules. You can assign multiple validation rules to any control.
Using the ValidationRules Collection Editor requires the Wisej.NET 3.2 VSIX to be installed within Visual Studio.
With Wisej.NET 3.2 we are introducing a new concept to build views using a JSON representation. In the future we may add XML or any custom parser, and we are also planning to use the new View Builder as an optional serializer in the designer.
Font support has been enhanced in the JavaScript layer as well as the server side .NET layer in Wisej.NET. Now we support using theme fonts that are not installed on the server.
The DevExpress Dashboard is a control that allows developers to create interactive and customizable dashboards for business intelligence (BI) purposes. The platform offers a wide range of data visualization tools and widgets, such as charts, graphs, maps, gauges, and pivot tables.
Using this extension requires a Developer Express license.
Added Enable HTTPS option to the new project wizard.
Now projects include the full applicationhost.config
file in /Properties, or in /My Project for VB.NET, preconfigured to listen to https://localhost:44391, for IIS Express and .NET 4.8.
For .NET Core it listens to the same https://localhost:44391 URL and it doesn't need to use applicationhost.config
.
improvements across the board.
Consolidated bug fixes and enhancements to all controls.
DataGridView memory footprint for large data sets has been reduced.
Expanded Binding and MVVM ICommand support to ToolBarButtons and MenuItems.
New BindableComponent base class to enable data binding on components.
We added the option to enable the design-time debug mode in the Designer Options dialog. When enabled, Wisej.NET will show the Edge renderer(s) it uses to display each control in the pixel-perfect design view.