|
Now with added Silverfish. WTF?
|
|
|
|
|
I really enjoy learning new things and I find WPF useful. That being said...it's difficult to explain the benefits of MVVM to management at times, especially since it's not as straight forward as event handling directly in the form code. They just see it as, "takes longer!". Hence, I'm working with Winforms lol.
|
|
|
|
|
Quote: Windows Presentation Foundation (WPF) is the answer for software developers
and graphic designers who want to create modern user experiences without having to
master several difficult technologies.
Ummm... XAML, MVVM, MEF, Prism... jumping off into WPF was the beginning of sorrows.
|
|
|
|
|
Actually it succeed. Silverlight, WPF, and WinRT have use same paradigm on styles, templates, datatemplate, visual state manager, resources.
Sure the API is not EXACTLY the same, the commerical name is different, but I don't think we should keep such expectation when devices and way of using the app is so different accross device.
Most of the code is copy/pastable or reusable through some clever "Add as Link" / #define in your code.
Learn WPF, and you learnt most of what you need to know on WinRT and Silverlight
|
|
|
|
|
Perhaps it's a solution to a problem that didn't exist.
If there is one thing more dangerous than getting between a bear and her cubs it's getting between my wife and her chocolate.
|
|
|
|
|
preaa wrote: If it were to separate UI completely with the behaviour, aren't the developers doing that already with clean layering architecture with the forms based applications? No they aren't. Have you seen how hard it is to get a complete break and clean layering going in Windows Forms?
preaa wrote: and why somebody would like to load a desktop application on a browser? If its a browser based application, it should be developed in ASP.NET Again no. There are much better alternatives to the bloat that is ASP.NET for web based applications, unless you are talking about ASP MVC. You are looking at the state of the world as it exists now, not back in 2003 when WPF was heavily under development. Back then, doing fancy UIs in ASP.NET was extremely limited.
The reason that WPF was invented, and this is from the team that wrote it in the first place, was because Microsoft wanted to provide developers to create the types of applications that people were used to seeing in films and TV shows, but which were not easily achievable in the technologies that were around at the time such as Windows Forms and MFC. They offered several advances over these technologies, including breaking away from using GDI/GDI+ for rendering, display independence, a sophisticated binding mechanism, animation, markup extensions, dependency properties and so on.
I would suggest that you start by reading Adam Nathan's excellent WPF Unleashed, as well as articles by Josh Smith, Sacha Barber, Dan Vaughan, Karl Shifflett, Jesse Liberty and so on.
|
|
|
|
|
Pete O'Hanlon wrote: he types of applications that people were used to seeing in films and TV shows
Bloody Minority Report has got a lot to answer for!
Never underestimate the power of human stupidity
RAH
|
|
|
|
|
For me, the problem WPF solves was rich UI. I've spent years in the MFC trenches writing owner-draw code and sophisticated layout management. I hate going back and maintaining those applications now, because WPF is so much simpler and more expressive.
Thanks, Pete. Those of us who actually like WPF appreciate it.
Software Zen: delete this;
|
|
|
|
|
As always, I enjoy and learn from your thoughtful remarks, Pete.
I think an issue anyone ... who's not already committed to, in the thick of ... WPF ... today ... faces is evaluating the future potential of investing time and energy to master a given Windows technology stack, like WPF, or ASP MVC, or RT/XAML/C#.
Several months ago, you hinted, in a message here on CodeProject, that you felt some exciting news was coming from Microsoft that might affect the perceptions of the future value of WPF ... information you could not share at the time (I infer) because you were under NDA.
Perhaps all of whatever you hinted at is already revealed; I'm not sure.
So, let me ask you a rhetorical question: if you had a bright young developer asking your advice at this time ... someone who's weighing technology stacks like ASP/MVC, HTML5/CSS3/JavaScript/jQuery/nodejs, Android/whatever, .NET technologies using XAML (WPF, Win RT, et. al.) ... and let's throw IOS in there for good measure ... what advice would you give them about where to invest their energy in learning and mastering a given stack, and getting productive with it ?
I don't mean for this to be "trick" question: obviously, what a person is already knowledgeable about comes into play here; as does whether they are looking to be employee or be an entrepreneur; whether their target platform is desktop, or smart-phones; whether making money is the goal, or achieving "fame and glory" is the goal ... and so on.
I'd really enjoy hearing any speculations you care to make, and I am sure other people here would enjoy them.
yours, Bill
“But I don't want to go among mad people,” Alice remarked.
“Oh, you can't help that,” said the Cat: “we're all mad here. I'm mad. You're mad.”
“How do you know I'm mad?” said Alice.
“You must be," said the Cat, or you wouldn't have come here.” Lewis Carroll
|
|
|
|
|
Right now, if I were advising a new developer, I would push them towards the MEAN stack (MongoDB, Express, Angular.js and Node.js). While WPF does have some future (sadly, I cannot reveal what it is - you're right that I'm under NDA), this release was probably the last that any new features would make it in; effectively it's now gone into maintenance mode.
So, why would I not recommend the "Metro" stack? Well, I'm just not convinced that Microsoft is going to get enough traction in the consumer device space to make it worthwhile for developers to really push into that space. If I were advising devs on looking at the consumer space, I'd recommend learning Java and pushing for Android, or learning Mono C# and targetting Android/iOS. At the end of the day, it's a numbers game, and until Microsoft change direction in their licensing, they will not make the huge inroads in the consumer space. It's not as though they had a form of monopoly on small form-factor device OS that they had on the PC OS market, so they really have their work cut out.
Realistically, I see Microsoft moving more towards the enterprise space and pushing things like Cloud services (their idea of an OS in the cloud really hints at this direction). I see that there will be a fair move in this space to the web world, which is why I recommend working with the MEAN stack - I'm currently writing an article on it for CP, and it's a really rich environment to work with. To give you an idea, here's one of the bits of code that I'm currently working on:
var mongoose = require('mongoose');
var Schema = mongoose.Schema;
var LanguageSchema = new Schema({
language: {type: String, required: true},
display: {type: String, required: true}
});
function languages() {
languageModel:null,
__constructor = function(){
this.languageModel = mongoose.model('language', LanguageSchema);
var languages = [
{language:'Csharp', display:'C#'},
{language:'VB.NET', display:'VB'},
{language:'cpp', display: 'C++'},
{language:'css', display:'CSS'},
{language:'html',display:'HTML'},
{language:'javascript',display:'JavaScript'},
{language:'java',display:'Java'},
{language:'perl',display:'Perl'},
{language:'php',display:'PHP'},
{language:'python',display:'Python'}
];
languages.forEach(function(language) {
this.languageModel.find({language:language.language}, function(err, lang) {
if (lang.length === 0) {
var lang = new languageModel({
language: language.language,
description: language.description
});
lang.save(function(err, myLang){});
if (!err)
console.log('Saved '+myLang.language);
else
console.log(err);
}
});
});
}()
this.findAll = function(req, res) {
return this.languageModel.find(function(err, lang) {
res.jsonp(lang);
});
}
};
module.exports = new languages(); Now, to use this with a RESTful service, all I need to do is this:
var languages = require('./routes/languages.js');
app.get('/languages', languages.findAll); That's how simple it is to create a RESTful API in the Node world. It's easy for new developers to get started with it and is all free. So, that's why I'd recommend it.
|
|
|
|
|
Well I think most of the other members already said why is was formed, but I would like to add the following. Please go and have a look at some of the articles drafted by Sacha Barber[^], which makes use of xaml (wpf, silverlight, metro), then I would like you to ask yourself one simple question; how easy / difficult / impossible would that have been in WinForms...
Kind regards,
|
|
|
|
|
Well thanks a lot again for the kind replies.. I think I should look at Windows RT as well along with WPF..
Best
|
|
|
|
|
WPF has the richest xaml-based feature set.
Silverlight was pretty much a stripped down version of WPF.
WinRT xaml looks like a stripped down version of silverlight ("looks like", because I haven't done anything worthwhile in it yet, it's just first impressions).
In any case, as long as you get the xaml principles down along with MVVM, you'll be up and running on all xaml platforms in no time. The learning curve can be quite steap though, it's a lot to take in at first. But it's real fun imo.
|
|
|
|
|
WPF - Why Program Functionally...need I say more?
|
|
|
|
|
As a Delphi developer I would say this is cycles of evolution.
In the beginning Delphi separated the design-time set properties into a binary dump.
Then it became obvious that sometimes it is necessary to hand-edit this file (ex. remove properties of changed components, reorder parents, etc.) so the dump file became human readable.
Change to .net.
Then in Visual Studio projects these human readable, easy to write visual designers for configuration files became ordinary source files so the coders see what happens, was easy to remove components with conditional compilation. But it was became obvious that it was hard to write a visual designer for it.
Then the configuration file became human-readable XML with option to compile it to binary form, and the cycle may restart.
|
|
|
|
|
Hi
Also don't look at it black and white. WPF has a ton of features you can use but you will also need a lot of time to get to know all of them. You can use only part of it for the start. You can start using it in a more WinForms-like way by handling UI events through event handlers and setting UI values directly instead of binding (ant not creating a mess on the way). With this, you can still use WPF's rich UI compositing feature which is light-years ahead of WinForms. You can do things you only dreamed about doing them in WinForms (unless you want to go low-level and draw controls by yourself).
By only using UI composition features you're far ahead of WinForms, not to mention other features. I don't see a reason going back to WinForms once you get to know WPF.
Best regards
T
|
|
|
|
|
Learn WPF and so you will understand both WinRT, Silverlight and Windows phone dev at the same time.
The name of the technology is different, but the way of developping is the same. There is a good chunk of code reuse between these devices. (Already copy/pasted a style of some Windows phone controls to my wpf app without changing anything, just to see it works as a charm).
Styles,VisualStateManager, ControlTemplate,DataTemplate,Resources, MVVM, Binding, all works the same on all these technologies. (As well as Expression Blend for Advanced design)
|
|
|
|
|
I'm with ya here. I played with WPF for awhile and didn't care for it. I still develop desktop Windows applications and the standard Windows Forms still works fine. I personally found WPF to be a method of making developing desktop applications as painful as web ones! You can have XAML as far as I'm concerned!
|
|
|
|
|
I agree. Unless you need some sort of 'clever' or 'fancy' UI, I don't see many advantages. Honestly, how many times have you wanted to re-style a whole UI.
WPF certainly has nothing to recommend it when considering updating apps built on 'old' frameworks like Froms or MFC.
|
|
|
|
|
with ShowUI in PowerShell there is no need of XML
a little tool with ShowUI in PowerShell :
Import-Module ShowUi
############################################################################
# Hibernate_WPF_V2.ps1
# start with Cmd-Batch example:
# @echo off
# cd /D C:\Users\Public\Documents\prog\Hibernate
# start powershell -STA -WindowStyle Hidden -Command .\Hibernate_WPF_V2.ps1
############################################################################
function global:Hours_and_Mins ( [Int16]$MinsTill ) {
if ( -not ( $MinsTill -gt 0 -and $MinsTill -lt 1440 ) ) {
return "--:--"
}
do { #get certain time
$nowdue = Get-Date
$now = Get-Date
$nowminutes = $now.Minute
$nowhours = $now.Hour
} while ( ( $nowminutes -ne $nowdue.Minute ) -or ( $nowhours -ne $nowdue.Hour ) )
$TimeAtTill = $now.AddMinutes( 0.5 + $MinsTill ) #a half minute in plus
# Write-Host ("TimeAtTill: " + $TimeAtTill.ToString("HH:mm:ss"))
$HoursAndMins = $TimeAtTill.ToString("HH:mm")
return ( $HoursAndMins )
}
function global:MinutesTill ( [string]$AtTimStr, [ref]$TodayTomor ) {
$now = Get-Date
try {
[DateTime]$AtTim = Get-Date $AtTimStr
} catch {
[DateTime]$AtTim = $now.AddMonths( 12 )
}
if ( ( [int64]$span = [Math]::round(( $AtTim - $now ).TotalMinutes )) -lt 0 ) {
$span += 1440
$TodayTomor.value = "tomorrow"
} else {
$TodayTomor.value = "today"
}
return ( $span )
}
function global:BtnOKdekorate ( [object]$Btn, [string] $clicked ) {
if ( $clicked -eq "clicked" ) {
$Btn.Tag = $Btn.Name
$Btn.FontSize = 13.0
$Btn.Content = "count down"
$Btn.Foreground = "green"
} else {
$Btn.Tag = $clicked
$Btn.FontSize = 22.0
$Btn.Content = "OK"
$Btn.Foreground = "black"
}
}
#############################################################
# main
#############################################################
New-Window -Name MainWindow -Width 200 -Height 286 -title 'Minutes till hibernate' `
-ResizeMode CanMinimize -Background Pink -Top 0 -Left 0 {
New-StackPanel -Margin 7 -Background Pink {
New-TextBox -Text "minutes`ntill hibernate" -IsReadOnly $True `
-Background Pink -BorderThickness 0 -FontFamily Arial -FontSize 22.0 `
-HorizontalContentAlignment Center `
-TextWrapping Wrap `
-On_GotFocus {
$TxtForMinutes.Focus()
}
New-Separator -Height 1 -Background Pink
New-Label "Minutes:" -FontFamily Consolas -FontSize 13.0 -FontWeight Bold
New-TextBox -Name TxtForMinutes -Text "0" <# init value defined in windows onLoad event routine #> `
-TabIndex 2 `
-FontFamily Consolas -FontSize 24.0 `
-HorizontalContentAlignment Right -FontWeight Bold -Tag "" `
-On_TextChanged {
# Write-Host ("enter Change Event for " + $this.name + "`: " + $this.gettype() + " Tag=" + $this.tag)
if ( $this.Tag.Length -gt 0 ) {
# Write-Host ("Enter code for the Change Event for " + $this.name + "`: " + $this.gettype() + " Tag=" + $this.tag )
try {
[int16]$Mins = [convert]::ToInt16($this.Text)
} catch {
[int16]$Mins = -1
}
if ( $btnOK.IsEnabled = ( $Mins -gt 0 -and $Mins -lt 1440 ) ) {
$this.Background = "white"
if ( $this.Tag -ne $TxtForTime.Name ) {
$ResultFromHours_and_Mins = Hours_and_Mins( $Mins )
# Write-Host ("after Hours_and_Mins " + $ResultFromHours_and_Mins + " from " + $Mins )
$TxtForTime.Tag = $this.Name #I'm the sender
$TxtForTime.Text = $ResultFromHours_and_Mins
}
} else {
$this.Background = "red"
}
if ( "X" -eq $this.Tag ) {
BtnOKdekorate $btnOK "X"
}
}
$this.Tag = "X"
}
New-Separator -Height 1 -Background Pink
New-Label "Time:" -FontFamily Consolas -FontSize 13.0 -FontWeight Bold
New-StackPanel -name StkForTime -Background Pink -Orientation Horizontal -HorizontalAlignment Center {
New-Label -Name "lblDay" -content " " -Background White -Width 100 `
-FontFamily Consolas -FontSize 20.0 `
-HorizontalContentAlignment Center -FontWeight Bold
New-TextBox -Name TxtForTime -Text "--`:--" -Width 80 `
-FontFamily Consolas -FontSize 24.0 `
-HorizontalContentAlignment Right -FontWeight Bold -Tag "" `
-On_TextChanged {
# Write-Host ("enter Change Event for " + $this.name + "`: " + $this.gettype() + " Tag=" + $this.tag)
if ( $this.Tag.Length -gt 0 ) {
# Write-Host ("Enter code for the Change Event for " + $this.name + "`: " + $this.gettype() + " Tag=" + $this.tag )
$TodayStr = ""
[int64]$span = MinutesTill ($this.Text) ([ref]$TodayStr)
# Write-Host ("after MinutesTill span=" + $span + " Todaystr=" + $TodayStr )
if ( $btnOK.IsEnabled = ( $span -le 1439 -and $span -ge 1 ) ) {
$this.Background = "white"
if ( $this.Tag -ne $TxtForMinutes.Name ) {
$TxtForMinutes.Tag = $this.Name #I'm the sender
$TxtForMinutes.Text = $span
}
} else {
$this.Background = "red"
$TodayStr = " "
}
if ( "Y" -eq $this.Tag ) {
BtnOKdekorate $btnOK "Y"
}
$lblDay.Content = $TodayStr
}
$this.Tag = "Y"
}
}
New-Separator -Height 15 -Background Pink
New-StackPanel -name StkForBtn -Background Pink -Orientation Horizontal -HorizontalAlignment Center {
New-Button -Content "OK" -name btnOK -Margin 5 -Width 80 -Height 32 `
-FontFamily Consolas -FontSize 22.0 -FontWeight Bold `
-Tag "" `
-On_Click {
BtnOKdekorate $this "clicked"
}
New-Button -Content "Cancel" -name btnCancel -Margin 5 -Width 80 -Height 32 -FontFamily Consolas -FontSize 22.0 -TabIndex 1 `
-On_Click {
Close-Control
}
} # end of second StackPanel
} # end of first StackPanel
} -on_Load {
#####################################################
$TxtForMinutes.text = "60" #initial Value of minutes
#####################################################
$btnCancel.Focus()
Register-PowerShellCommand -ScriptBlock {
# Write-Host ("TimerEvent at " + ( Get-Date ).ToString("HH:mm:ss") )
if ( $btnOK.Tag -eq $btnOK.Name ) {
# calc new minutes from now and TxtForTime
$TodayStr = ""
[int64]$MinsByTimer = MinutesTill ($TxtForTime.Text) ([ref]$TodayStr)
$TxtForMinutes.Tag = $TxtForTime.Name #simulate that Inf comes from TxtForTime
$TxtForMinutes.Text = $MinsByTimer
if ( 0 -eq $MinsByTimer ) {
# disable further processings
$btnOK.IsEnabled = $False
$btnOK.Tag = "Z"
# shutdown /h
$EXE = 'C:\Windows\System32\shutdown.exe'
[string[]]$PARGS = '/h'
# Write-Host ( "Hibernate with " + $EXE + " " + $PARGS )
start-process $EXE -ArgumentList $PARGS -NoNewWindow
$btnOK.Content = "hibernated"
$btnOK.Foreground = "cyan"
}
} else {
if ( $btnOK.IsEnabled ) {
[int16]$MinsByTimer = [convert]::ToInt16($TxtForMinutes.Text)
$Hours_and_MinsByTimer = Hours_and_Mins( $MinsByTimer )
# Write-Host ("after Hours_and_Mins " + $Hours_and_MinsByTimer + " from " + $MinsByTimer )
$TxtForTime.Tag = $TxtForMinutes.Name #simulate that Inf comes from TxtForMinutes
$TxtForTime.Text = $Hours_and_MinsByTimer
}
}
} -run -interval "0:0:30" #each 30 seconds
} -show > $Null
modified 28-Feb-14 12:42pm.
|
|
|
|
|
Funny as the main reason presented here is the polished look and feel you get from WPF. Yet if you look at Windows 8+ and Visual Studio 2012 and on, the visual interfaces are absolutely ugly. Polished look - where? What an excuse to force an ugly practically useless product onto developers.
|
|
|
|
|
I did not buy Visual Studio for a polished look. I want something that is there when I need it, and gets out of the way when I don't. I have found VS2012 (2010 also used WPF BTW) and VS2013 to be pretty good about that. The ui elements do not draw any undue attention to them and I can focus on my work. Additionally, I have some degrading eyesight and the Dark Theme in 2012 and 2013 work wonderfully for me. The monochrome-ish design supports the dark theme. Too many colors would make the dark theme unusable.
|
|
|
|
|
Don't know if this has been answered but will take the liberty to state it again.
WPF was an ambitious plan to change the way we work with Windows development. It was part of Framework 3.0 which was a part of Vista. Ironically it wasn't a full Framework at all, but just three sets of BIG APIs designed to change different parts of the coding process.
Before we delve into WPF, we must touch the other two (Windows Communication Foundation [WCF] and Windows Workflow Foundation [WF]) and know that all three share the same XAML description language.
WCF is a modern replacement for the old .asmx model which allows you to build a Web Service inside any CIL *.exe and build Web Services beyond SOAP. I currently use them to connect BizTalk to SAP using SAP Connector.
WF was an ambitious plan to create Enterprise Service Bus potential in everyday applications, connecting WebServices to business flows and logic, using graphic programming.
Last, but not least, came WPF, the Windows Presentation Foundation, which was an attempt to 'reimagine' the desktop experience. It was thought that during Vista, application developers would abandon Win32 in favor of WPF. That didn't happened since the impact of the Web was far greater than Microsoft had expected. Enterprise had already went full web and all modern application development was being done in Java or ASP.NET.
So Microsoft created Silverlight, to revive WPF into a Web Plus thing, just like Flash. But then came the mobile revolution and people started making apps instead of applications, and apps became companions to web pages (aka a thin client world).
Today WPF lives on in the Metro paradigm for both Windows 8 and Windows Phone 8. Windows Phone 7 was a type of Silverlight, but WinRT (the common framework for 8's) is more WPF like. All Metro apps can communicate with WCF services and could (theoretically) use WF workflows. Few people are going this route as Node.js and JSON have replaced SOAP as a communication approach except in the B2B side.
As for the reason to use an XML markup system to describe the app, instead of doing it graphically and programmatically like WinForms, you must know that the concept behind WPF was that the markup is just a partial class of the codebehind. That way you could have the View separated from the Controller and Model. This was an approach created by the NeXT Cube and NextStep (the fore father of iOS and OS X) in a system called Model-View-Presenter. The language used was called a plist had no programmatic equivalent which allowed more flexibility and no need to translate the graphic approach and no need for interface construction during startup, thus generating faster code.
Blessings are not just for the ones who kneel. Luckily...
|
|
|
|
|
I really enjoyed this eloquent analysis, thanks ! I did some work on the NeXT machine back in the day; it was interesting, but short-lived.
For me, I see no difference, except outer format, between the Designer.cs code-behind in Windows Forms, and XAML in WPF, except that in WPF I found the XAML got in the way of designing, and designing got in the way of XAML ... but, perhaps I didn't hang in there long enough with WPF to reach even the first plateau in the learning curve (which most programmers do describe as "steep").
One reason for not sticking with WPF had to with my perception it did not have a reliable future, as an investment of my time, and intellect.
Never understood why the code-behind in Win Forms wasn't written in some XML compatible format, anyhow.
“The best hope is that one of these days the Ground will get disgusted enough just to walk away ~ leaving people with nothing more to stand ON than what they have so bloody well stood FOR up to now.” Kenneth Patchen, Poet
|
|
|
|
|
What you are talking about is more of a XAML nature. While XAML is a part of WPF, it is only the popular method by which WPF user interface items are expressed. WPF itself has a lot more to do with performance, binding, and event handling than just XAML.
For instance, WPF offloads almost all UI display processing to the graphics hardware, while Windows Forms relies on the CPU to process each repaint.
WPFs binding ability, arguably one of it's neatest and most useful features allows for true (and fairly simple to implement) separation of concerns between application logic and UI display logic.
I will also say that the UI elements have a very good dynamic sizing engine built under them. I could never have done some of the things that I have done in WPF with Windows Forms.
|
|
|
|
|