Wel vreemd eigenlijk dat je binnen twee dagen berichten over de pensioenfondsen leest die elkaar lijken tegen te spreken…
Pensioenfondsen korten
Toch wel opmerkelijk
Kortingen op komst bij grote pensioenfondsen
Laatste update: 19 januari 2012 11:24 info
RIJSWIJK – Drie van de vijf grootste pensioenfondsen van ons land moeten aanvullende maatregelen nemen om hun dekkingstekorten weg te werken.
Foto: ANP
Als substantieel herstel van hun financiële situatie dit jaar uitblijft, zullen de metaalpensioenfondsen PME en PMT en het ambtenarenpensioenfonds ABP volgend jaar het mes moeten zetten in de pensioenen.
ABP, het grootste Nederlandse pensioenfonds, ziet een verlaging van de pensioenen met een half procent als ”een reële optie”.
Bij PMT zal de korting naar verwachting 6 tot 7 procent bedragen. PME gaf nog geen indicatie van de te verwachten korting. Besluiten daarover zullen bij alle drie de fondsen in februari genomen, of ze daadwerkelijk worden uitgevoerd is afhankelijk van de dekkingsgraden eind dit jaar.
ABP
De dekkingsgraad bij ABP verbeterde in het laatste kwartaal van 2011 tot 94 procent, maar dat herstel is volgens de regels van De Nederlandsche Bank (DNB) te mager.
”Als nieuwe voorzitter van ABP had ik onze deelnemers heel graag beter nieuws gebracht, maar helaas zijn wij bij deze dekkingsgraad genoodzaakt aanvullende maatregelen te treffen”, aldus voorzitter Henk Brouwer.
Zorg en Welzijn
Pensioenfonds Zorg en Welzijn (PFZW) hoeft vooralsnog niet in te grijpen in de pensioenuitkeringen. ”We hoeven op dit moment geen pijnlijke extra maatregelen te nemen”, zei directeur Peter Borgdorff.
Ook het Bedrijfstakpensioenfonds voor de Bouwnijverheid (BPF Bouw) hoeft de pensioenen waarschijnlijk niet te verlagen, mits de situatie op de financiële markten dit jaar verbetert.
—-
AMSTERDAM – Hoewel de dekkingsgraden door de lage rentestand dalen, is het totale vermogen van alle Nederlandse pensioenfondsen tijdens het afgelopen jaar naar een record van 875 miljard euro gegroeid.
Dat blijkt uit berekeningen die televisiezender RTL Z maakte op basis van gepubliceerde “en nog niet gepubliceerde” data. Begin 2011 stond de teller nog op 801 miljard euro, waarna er dankzij winsten op obligatieportefeuilles 9 procent aan vermogen werd gewonnen.
Het zorgpensioenfonds PFZW zag zijn vermogen het sterkst toenemen, van 99,5 miljard euro naar 110,7 milard euro (een rendement van 11,3 procent).
Het ambtenarenfonds ABP kreeg er 3,8 procent bij en heeft nu 246 miljard euro in kas. Het ABP kondigde deze week net als veel andere fondsen kortingen en stijgende pensioenpremies aan, doordat de dekkingsgraad onder invloed van de lage rente daalt.
Aanvullende maatregelen
De dekkingsgraad van ABP is over heel 2011 met 11 procentpunt gedaald en bedraagt nu 94 procent. Drie van de vijf grootste pensioenfondsen moeten aanvullende maatregelen nemen om hun dekkingstekorten weg te werken als financieel herstel uitblijft.
De gemiddelde dekkingsgraad van de Nederlandse pensioenfondsen zal de komende maanden bij een gelijkblijvende rentestand verder dalen tot 93 procent, zo meldde pensioenadviseur Mercer woensdag.
Nederlands pensioenbezit 875 miljard euro
Nederlands pensioenbezit 875 miljard euro
20 JAN 2012( LAATSTE UPDATE: 21 JAN 2012 )
De Nederlandse pensioenfondsen zijn nog nooit zo rijk geweest als nu, het geld klotst over de reling.
Eind 2011 liep het totale vermogen op tot 875 miljard euro, een record!
Meer dan ons Nationaal Inkomen
Het jaar 2011 begonnen de gezamenlijke pensioenfondsen met een totaal beschikbaar vermogen van 801 miljard euro. Door de gigantische winsten op de obligatieportefeuilles zijn de fondsen vorig jaar 74 miljard euro rijker geworden, een plus van ruim 9%. Alleen al het laatste kwartaal leverde 40 miljard euro op.
Dat blijkt uit voorlopige berekeningen van RTL Z op basis van gepubliceerde en nog niet gepubliceerde data.
Het pensioenbezit is de afgelopen verdubbeld en maakt van Nederland een rijk land. Het pensioenvermogen is ruim 140% van ons BNP van 600 miljard euro per jaar en dat is best uniek!
Opvallende en noemenswaardige fondsen:
.
Jong en rijk
Pensioenfonds voor de Zorg (PFZW) heeft de grootste klapper van het jaar gemaakt. Het ‘groene’ fonds met veel jonge werknemers werd maar liefst 11,2 miljard euro rijker. Het fondsvermogen steeg van 99,5 tot 110,7 miljard, een plus van 11,3%. PFZW heeft 31% rendement gemaakt op de obligatieportefeuille en de rente- en inflatieafdekking. De daling van de rente bracht de dekkingsgraad weliswaar naar 97%, maar de kas van de penningmeester is nog nooit zo goed gevuld geweest.
Oud en grijs
Het veel ‘grijzere’ fonds ABP zag zijn vermogen ‘slechts’ toenemen met 9 miljard euro (3,8%) van 237 tot 246 miljard euro. Dat is wel een recordhoogte. Het ABP heeft minder geprofiteerd van rentedalingen dan de andere fondsen, het fonds had minder rentederivaten gekocht.
Noodlijdend
Opvallend ook is dat het noodlijdende metaalfonds PME het bezit heeft zien stijgen met 14%. Het fondsvermogen steeg van 22,6 tot 25,8 miljard euro. PME heeft echter een dekkingsgraad van slechts 90%, het fonds moet daarom in april 2013 6 tot 7% korten op de pensioenen.
Gezond
Het vrij gezonde pensioenfonds voor de medewerkers van de Spoorwegen is dit jaar niet veel opgeschoten in vermogen. Het totale bezit steeg slechts van 10,86 miljard naar 11,18 miljard, een plus van bijna 3%. De deelnemers kunnen overigens opgelucht slapen, de dekkingsgraad is 113%. Het fonds hoeft daarom niet af te stempelen, het zou volgend jaar de pensioenen zelfs kunnen indexeren voor inflatie. Zoekt u een baan, dan zou u conducteur kunnen worden…
45% pensioen premie
Shell komt volgende week met de jaarcijfers. Het eigen pensioenfonds zit daarom nu in de ‘silent periode’ en wil het pensioenvermogen niet bekend maken. Het fonds had eind 2010 een vermogen van 17,5 miljard euro met een dekkingsgraad van 123%.
De dekkingsgraad is in 2011 gedaald naar 111%, met een ontoereikend vermogen op lange termijn. Derhalve heeft het bestuur besloten de pensioenpremie te verhogen naar 45% van de pensioengrondslag (het salaris min de zogenoemde franchise). De werkgever betaalt 41,6% premie. De werknemer met een salaris tot 77.000 euro betaalt zelf slechts 2%, daarboven 8%. Voor uw carrière kunt u dus misschien het beste aan Shell denken, pomphouder?
Nationaal vermogen gestegen door grotere pensioenpot
24-2-2016 05:30
Het vermogen van Nederland is sinds het begin van de crisis gegroeid. Dat komt vooral doordat het vermogen van pensioenfondsen en verzekeraars sinds 2008 met ruim 615 miljard euro groeide tot 1,7 biljoen euro in het derde kwartaal van 2015. Dat meldt CBS op basis van een vandaag voor het eerst gepubliceerd overzicht.
lees hier verder: www.cbs.nl
of hier:
Het netto nationaal vermogen is het vermogen van de Nederlandse huishoudens, bedrijven en de Nederlandse overheid samen, ofwel de Nederlandse bezittingen minus de schulden. Dat vermogen bedroeg eind 2014 bijna 3,7 biljoen euro. Dat is 292 miljard euro meer dan eind 2008.
Het netto vermogen van Nederland is een combinatie van financiële bezittingen (zoals aandelen, obligaties en deposito’s) en materiële bezittingen, minus schulden. De waarde van die materiële of niet-financiële bezittingen (zoals vastgoed, wegen en machines) is sinds 2008 afgenomen. Dat kwam onder meer doordat onroerend goed minder waard werd nadat de woningmarkt inzakte. De stijging van het totaal is dus volledig het gevolg van de toename van die andere tak: het financiële bezit.
Financieel bezit
Het financiële bezit van Nederland ten opzichte van het buitenland wordt gemeten door de Nederlandse vorderingen en schulden in het buitenland van elkaar af te trekken. Het bedrag dat daar uitkomt is het zogeheten Nederlandse externe vermogen.
Dat externe vermogen lag eind 2008 48 miljard euro in de min: Nederland was het buitenland meer verschuldigd dan andersom. Maar aan het einde van het derde kwartaal van 2015 was het externe vermogen gestegen naar een overschot van liefst 568 miljard euro. Het gaat hier alleen om de vermogensposities ten opzichte van het buitenland: de binnenlandse vorderingen en schulden zijn in de berekening tegen elkaar weggestreept. Een lening van bijvoorbeeld een Nederlands bedrijf bij een Nederlandse bank is immers een schuld bij de ene partij (het bedrijf) en een even grote vordering bij de andere partij (de bank).
Door het nieuwe overzicht is nu per sector duidelijk welke vorderingen en schulden ze onderling en met het buitenland hebben, waardoor beter inzichtelijk wordt waar die stijging tussen 2008 en 2015 vandaan komt. De toename van het netto extern vermogen ligt vooral bij de pensioenfondsen, maar is daarom indirect naar de huishoudens terug te voere
Meer vermogen nodig door lage rente
Nederlandse huishoudens hebben sinds 2008 hun aanspraken op verzekeraars en pensioenfondsen sterk zien groeien. Eind september 2015 bedroeg dit bijna 1,5 biljoen euro, tegen 858 miljard euro eind 2008. Het gaat voor het merendeel om pensioenaanspraken. Die aanspraken staan hier voor het totale vermogen waarover verzekeraars en pensioenfondsen moeten beschikken om aan hun pensioenverplichtingen te kunnen voldoen.
De stijging in aanspraken komt vooral doordat de rekenrente gedaald is. Die rente vormt een maat voor het toekomstig rendement van pensioenfondsen en daarmee voor het benodigde vermogen dat de fondsen moeten aanhouden om toekomstbestendig te blijven. Hoe lager de rekenrente, hoe hoger het vereiste vermogen. Hoe hoger het vermogen, hoe hoger de huidige waarde van de pensioenaanspraken van huishoudens. Fondsen hebben de afgelopen jaren ook meer vermogen moeten aanhouden vanwege aanpassingen in de levensverwachting, maar de invloed daarvan is veel kleiner dan van de rentedaling.
Pensioenfondsen moeten sinds de crisis dus veel grotere vermogens aanhouden om aan de toekomstige verplichtingen te kunnen blijven voldoen. Het vermogen van pensioenfondsen en verzekeraars, die ook een deel van het pensioenvermogen beheren, steeg dus tussen eind 2008 en september 2015 met ruim 615 miljard euro naar 1,7 biljoen euro.
Toename vermogen
Er zijn een aantal factoren waardoor de vermogens van de fondsen sinds 2008 zijn gegroeid. Ten eerste daalde de kapitaalmarktrente na 2008 vrijwel onafgebroken. De obligaties die pensioenfondsen in handen hadden, werden meer waard. Dat kwam doordat de couponrente op oude obligaties hoger was dan de marktrente. Daarnaast stegen aandelenkoersen en werden buitenlandse beleggingen meer waard doordat de meeste buitenlandse valuta’s, zoals de Amerikaanse dollar, de Zwitserse frank en het Britse pond, in waarde stegen ten opzichte van de euro. Tot slot verhoogden fondsen hun premies en stegen pensioenuitkeringen niet mee met de inflatie of werd er zelfs op gekort.
Verzekeraars en pensioenfondsen beleggen lang niet alles zelf, maar brachten de voorbije jaren een deel van hun kapitaal onder bij beleggingsinstellingen, waardoor hun aanspraken op die instellingen stegen. De aanspraken van beleggingsinstellingen op het buitenland namen weer fors toe doordat ze het door de pensioenfondsen ingebrachte geld voor een groot deel buiten Nederland gingen investeren. Overigens zijn de directe beleggingen van pensioenfondsen in het buitenland ook toegenomen.
Omdat pensioenfondsen (en beleggingsinstellingen) nauwelijks financiële verplichtingen (schulden) in het buitenland hebben, heeft de groei van het pensioenvermogen een groot effect gehad op de toename van het externe vermogen.
Europese Unie
Een negatief extern vermogen geeft aan dat een land financieel kwetsbaar is. Het land heeft dan immers veel schulden in het buitenland, wat vaak gepaard gaat met langdurige rentebetalingen en aflossingen. Daarom heeft de Europese Commissie dit vermogen opgenomen in een scorebord dat macro-economische onevenwichtigheden bij landen moet meten. Het rapport daarover komt binnenkort uit.
Nederland heeft, gemeten naar de grootte van de economie, het hoogste netto extern vermogen van Europa. De omvang en opzet van het Nederlandse pensioenstelsel, dat tamelijk uniek is in Europa, is hier voor een belangrijk deel de oorzaak van. Overigens moet een hoog netto extern vermogen niet worden verward met de rijkdom van een land. Het gaat hier slechts om de financiële positie ten opzichte van het buitenland: binnenlands opgebouwd vermogen wordt niet meegeteld.
How to use an SQL query with parameters in Excel
1 Intro
2 Set up the query to run as a stored procedure
3 Prepare Excel
4 Make ODBC connection to database in SQL
5 Prepare “Microsoft query”
6 Link fields to query parameters
Simple example query:
declare @StartDate datetime set @StartDate = ‘2018-01-01’
declare @EndDate datetime set @EndDate = ‘2018-01-31’ select * from tblOrder where orderdate <= @StartDate and orderdate >= @EndDate |
Create and run a script that creates a stored procedure:
CREATE PROCEDURE spSelectOrder
— Add the parameters for the stored procedure here @StartDate As DateTime, @EndDate As DateTime AS BEGIN — SET NOCOUNT ON added to prevent extra result sets from — interfering with SELECT statements. SET NOCOUNT ON; — Insert statements for procedure here select * from tblOrder where orderdate <= @StartDate and orderdate >= @EndDate END GO |
This stored procedure can be run in Excel using Microsoft query. To run this query, prepare a worksheet with the parameters filled. These parameters will be used as input for the query later.
Next step is to add the data source to the worksheet. Start Data, “From Other Sources” “From Microsoft Query”. This will start a wizard to create a data connection:
1 Select or create a Data Source
2 The next step in the wizard is Choose Columns. Cancel the wizard on this screen and a question will pop up asking you if you want to continue editing this query. Click Yes.
3 MS Query will be started and a dialog to select tables will be presented. Close this dialog.
4 Click SQL button in button bar or in menu choose View, SQL.
5 Type “call” followed by the stored procedure name and question marks for the parameter input between parentheses. Place this in between curly bracets. These curly bracets are required to avoid syntax check errors.
{call spMassBalans (?, ?)}
6 Press OK and you will be prompted to input values for the required parameters.
The results will be retrieved in a query result window. After the result is presented go to File and click “Return Data to Microsoft Excel”.
Microsoft query will be closed and you will return to Excel with a dialog to import the data. Choose cell A4 in the work sheet.
Again you will be prompted to input values for the parameters. This time you are able to select the cells B1 and B2 as input. Check the checkbox in the dialog to use the reference for future use. If you want you can also check to refresh the data when the cell value changes.
If you want to manually refresh the data you can right-click anywhere in the datagrid and select “refresh”.
How to develop with various app.config files
When I want to test my application in Microsoft Visual Studio I want to use a alternate app.config from production. In my development environment I have other connection strings etc.
To switch between development and production configuration I have come up with the following configuration:
I want to switch configuration in the IDE and use the apropriate app.config file.
For each environment I have added a separate app.config.file to my project.
Next I have added a pre-build.bat and a post-build.bat in the solution.
The pre-build.bat file contains one command to replace app.config for the selected configuration:
copy /y %1\app.config.%2 %1\app.config
The post-build.bat file contains one command to replace the app.config with the release or “production” configuration.
Last step is to tie these components all together. Add a Pre-build and a Post-build event in the project properties page. You should be able to find these settings right clicking the project and click on properties.
The command I added to start pre-build.bat is:
“$(ProjectDir)pre-build.bat” “$(ProjectDir)” “$(ConfigurationName)”
and for the post-build.bat the command is:
“$(ProjectDir)post-build.bat” “$(ProjectDir)”
De vloot
We bouwen en vliegen met de hele familie.
Mijn vader is een poosje geleden (begin 80-er jaren) begonnen met balsa vliegtuigen bij een bouw en vliegclub (BVL) ergens tussen Oud-Gastel en Moerstraten. De club verhuisde daarna vrij snel naar Kruisland.
Ik en mijn broer gingen ook regelmatig mee maar waren toen nog te jong om zelf te mogen en kunnen vliegen.
Later hebben we met zijn drieën het vliegen opnieuw opgepakt en zijn we lid geworden van een vliegclub in Rilland Bath (Alouette). Dit laatste vliegveld was echter een heel eind bij ons vandaan waardoor dat op de lange duur niet echt praktisch bleek.
Sinds 2015 zijn we overgestapt op elektrische motorvliegtuigmodellen. Mijn neefje heeft ook de smaak te pakken gekregen en vliegt nu met ons mee.
Continuously Deploy Your ClickOnce Application From Your Build Server
http://blog.danskingdom.com/continuously-deploy-your-clickonce-application-from-your-build-server/ from Daniel Schroeder’s (aka deadlydog) Programming Blog
ClickOnce applications are a great and easy way to distribute your applications to many users, and have the advantage of offering automatic application updates out-of-the-box. Even though ClickOnce applications are super easy to deploy from Visual Studio (literally 3 clicks, just click Build –> Publish –> Finish), you may still want to have your build system publish the updates for various reasons, such as:
You don’t want you (or your team members) to have to remember to manually publish a new version all the time; even if it is very quick and easy.
If you are signing your ClickOnce application (to make your app more secure and avoid annoying Windows security warnings during every update), your team members may not have the certificate installed, or you may not want them to know the certificate password.
All of the other benefits of deploying automatically from a build server; you can be sure the project was built in Release mode, all unit tests have run and passed, you are only publishing a new version of the application from a specific branch (e.g. master), etc.
In this post I’m going to show how to continuously deploy your ClickOnce application using Visual Studio Team Services (VSTS), but you can adopt what’s shown here to work on any build system, such as Team City or Jenkins.
Step 1 – Configure and publish your ClickOnce application manually
Before we can publish a new version of the application from the build server, we first have to build the project to create the artifacts to publish. And even before that, we have to make sure the project is setup properly with all of the required ClickOnce metadata. You will typically do this by going into your project Properties page and going to the Publish tab. There are several other websites and blog posts that discuss configuring a project for ClickOnce deployment, including the official MSDN documentation for configuring and publishing ClickOnce applications, so I won’t go into it any further here.
Basically you should have your project in a state where you can easily publish a new version manually, and it is configured the way that you want (includes the necessary files, has the destination to publish to specified, specifies if the application is only available online or not, etc.). Once you’ve published your project manually and confirmed that it’s configured the way you like, we can move onto the next step.
Step 2 – Setup the build on your build server
On your build server you will want to configure a new vanilla build that builds your project/solution. There are a couple modifications you will need to make that are different from building a regular console app or class library project.
The first difference is that you will need to provide the “/target:Publish” argument to MSBuild when it builds your project. Here is what this looks like in VSTS:
This will cause MSBuild to build the required artifacts into an “app.publish” directory. e.g. bin\Debug\app.publish.
The next difference is that you will want to copy that “app.publish” directory to your build artifacts directory. To do this, you will need to add a Copy Files step into your build process that copies the “app.publish” directory from the ClickOnce project’s bin directory to where the build artifacts are expected to be. You will want to do this before the step that publishes your build artifacts. Here is what this looks like in VSTS:
So we copy the files into the build artifacts directory, and then the Publish Build Artifacts step at the end will copy those files to wherever you’ve specified; in my case it’s a network share.
If you like you can now run the build and see if it succeeds. If the build fails with an error relating to an expired certificate or pfx file, see my other blog post on importing the required certificate on the build server at build-time, which involves adding one more “Import-PfxCertificate.ps1” build step before the MSBuild step.
For completeness sake, this is what my Publish Build Artifacts step looks like in VSTS, and you’ll also notice the “Import-PfxCertificate.ps1” step before the MSBuild step as well:
So we now have the ClickOnce artifacts being generated and stored in the appropriate directory. If you wanted, you could publish the build artifacts to the ClickOnce application’s final destination right now (instead of a file share as I’ve done here), but I’m going to follow best practices and separate the application “build” and “deployment” portions into their respective subsystems, as you may want separate control over when a build gets published, or maybe you don’t want to publish EVERY build; only some of them.
Hopefully at this point you are able to create a successful build, but we’re not done yet.
Step 3 – Publish the build artifacts to the ClickOnce application’s destination
Now that we have the build artifacts safely stored, we can publish them to the ClickOnce application’s destination. With VSTS this is done by using the Release subsystem. So create a new Release Definition and setup an Environment for it. By default it adds a “Copy and Publish Build Artifacts” step to the release definition. When configuring and using this default step, I received the error:
[error]Copy and Publish Build Artifacts task is not supported within Release
So instead I removed that default step and added a simple “Copy Files” step, and then configured it to grab the files from the file share that the build published the artifacts to, and set the destination to where the ClickOnce application was publishing to when I would do a manual publish from within Visual Studio. Here is what that step looks like in VSTS:
You should be able to run this release definition and see that it is able to post a new version of your ClickOnce application. Hooray! I setup my releases to automatically publish on every build, but you can configure yours however you like.
If you make changes and commit them, the build should create new artifacts, and the release should be able to publish the new version. However, if you launch your ClickOnce application, you may be surprised that it doesn’t actually update to the latest version that you just committed and published. This is because we need one additional build step to actually update the ClickOnce version so it can detect that a new version was published. If you launch another build and publish them, you’ll see that the files being published are overwriting the previous files, instead of getting published to a new directory as they are supposed to be.
You may be wondering why we need another build step to update the ClickOnce version. Part of the build artifacts that are created are a .application manifest file, and a directory that contains the applications files, both of which have the ClickOnce version in them. Can’t we just modify the directory name and .application manifest file to increment the old version number? This was my initial thought, but the .application manifest file contains a cryptography hash to ensure that nobody has tampered with it, meaning that it needs to contain the proper version number at the time that it is generated.
Step 4 – One more build step to update the ClickOnce version
The ClickOnce version is defined in your project file (.csproj/.vbproj) (as the <ApplicationVersion> and <ApplicationRevision> xml elements), and is different from the assembly version that you would typically set to version your .dll/.exe files via the AssemblyInfo.cs file. Unless you manually updated the ClickOnce version in Visual Studio, it will still have its original version. When publishing the ClickOnce version in Visual Studio, Visual Studio automatically takes care of incrementing ClickOnce version’s Revision part. However, because we’re publishing from our build system now, we’ll need to come up with an alternative method. To help solve this problem, I have created the Set-ProjectFilesClickOnceVersion GitHub repository. This repository houses a single Set-ProjectFilesClickOnceVersion.ps1 PowerShell script that we will want to download and add into our build process.
In order for the build system to access this Set-ProjectFilesClickOnceVersion.ps1 script you will need to check it into source control. Also, you need to make sure you add this build step before the MSBuild step. Here is what this step looks like in VSTS:
The Script Filename points to the location of the Set-ProjectFilesClickOnceVersion.ps1 script in my repository. Also note that I set the Working Folder to the directory that contains the .csproj project file. This is necessary since we are dealing with relative paths, not absolute ones.
For the Arguments I provide the name of the project file that corresponds to my ClickOnce application, as well as the VSTS Build ID. The Build ID is a globally unique ID that gets auto-incremented with every build, and most (all?) build systems have this. The script will translate this Build ID into the Build and Revision version number parts to use for the ClickOnce version, to ensure that they are always increasing in value. So you should never need to manually modify the ClickOnce version, and every build should generate a version number greater than the last, allowing the ClickOnce application to properly detect when a newer version has been published.
Maybe you update your application’s version number on every build, and want your ClickOnce version to match that version. If this is the case, then use the –Version parameter instead of –BuildSystemsBuildId. The other alternative is to use the –IncrementProjectFilesRevision switch to simply increment the ClickOnce Revision that is already stored in the project file. If you use this switch, you need to be sure to check the project file back into source control so that the Revision is properly incremented again on subsequent builds. I like to avoid my build system checking files into source control wherever possible, so I have opted for the BuildSystemsBuildId parameter here.
The last argument I have included is the UpdateMinimumRequiredVersionToCurrentVersion parameter, and it is optional. If provided, this parameter will change the ClickOnce application’s Minimum Required Version to be the same as the new version, forcing the application to always update to the latest version when it detects that an update is available. I typically use this setting for all of my ClickOnce applications. If you still plan on publishing your ClickOnce applications from Visual Studio, but want this functionality, simply install the AutoUpdateProjectsMinimumRequiredClickOnceVersion NuGet Package.
That’s it! Now if you launch another build it should create new artifacts with a larger ClickOnce version number, and once published your application should update to the new version.
Bonus – Displaying the ClickOnce version in your application
The ClickOnce application version number may be different than your assembly version number, or perhaps you don’t update your product’s version number on every publish; it’s easy to forget. I typically like to use semantic versioning for my projects, which only involves the first 3 version parts. This leaves the last version part, the Revision number, available for me to set as I please. I will typically use the ClickOnce Revision in my application’s displayed version number. This makes it easy to tell which actual release a client has installed in the event that the product version was not updated between releases. The code to do it is fairly simple.
public Version ApplicationVersion = new Version(“1.11.2”);
private void MainWindow_Loaded(object sender, RoutedEventArgs e)
{
// If this is a ClickOnce deployment, append the ClickOnce Revision to the version number (as it gets updated with each publish).
if (ApplicationDeployment.IsNetworkDeployed)
ApplicationVersion = new Version(ApplicationVersion.Major, ApplicationVersion.Minor, ApplicationVersion.Build,
ApplicationDeployment.CurrentDeployment.CurrentVersion.Revision);
// Display the Version as part of the window title.
wndMainWindow.Title += ApplicationVersion;
}
Here I hard-code the product version that I want displayed in my application in a variable called ApplicationVersion. When the WPF application is launched, I obtain the ClickOnce Revision and append it onto the end of the version number. I then display the version in my application’s window title, but you might want to show it somewhere else, such as in an About window. If you want, you could even display both the full application version and full ClickOnce version.
Bouwen en vliegen in het klein
Bouwen van het model
Tegenwoordig zijn er modellen te koop die met enkele uren bouwen vliegklaar zijn. Qua kosten hoeven deze niet duurder te zijn dan volledige bouwpakketten. De bouwdozen zijn vaak minder compleet dan de “Almost ready to fly”-modellen.
Om te beginnen met vliegen zijn deze laatste serieus aan te bevelen. Voor de volledige bouwpakketten is meer ervaring en aandacht nodig omdat er aan veel zaken gedacht moet worden zoals precies gelijke vleugels, de balans en het gewicht, het staartstuk moet precies recht achter het vliegtuig en alle vleugels en stuurvlakken moeten vlak of met precies de juiste bolling gebouwd worden.
Balans van het vliegtuig
De juiste balans links/rechts: als het vliegtuig bij de propellerdop wordt vastgepakt en onder de staart met een vinger op wordt getild moet het vliegtuig niet steeds een kant op vallen. Dit betekent dat het vliegtuig uit balans is. De ene vleugel kan dan zwaarder zijn dan de andere. Mocht dit het geval zijn is dit vaak op te lossen door in een vleugeltip extra gewicht aan te brengen bijvoorbeeld een klein stukje lood.
De juiste balans voor/achter: als het vliegtuig in het verlengde van het balanspunt (altijd op tekening aangegeven) aan beide zijden met de vleugels opgetild wordt, moet het zwaartepunt een stukje naar voor hiervan liggen. Dit is te zien aan het feit dat de neus dan enigszins omlaag zal wijzen.
Installatie van de motor
De motor moet op de juiste manier op de romp gemonteerd worden. Bij veel modellen is dat enigszins scheef op de romp. Dit staat op de bouwtekening aangegeven. Ook dient de motor de juiste motordomp te hebben. Dat houdt in dat de motor met de juiste hoogterichting geplaatst is.
De motor heeft een brandstofaanvoer bij de carburateur. Mogelijk zit op de uitlaat nog een aansluiting naar de brandstoftank. Hiermee kan de brandstoftank onder druk gezet worden zodat de toevoer naar de carburateur wat soepeler verloopt.
Ga niet vliegen met een motor die niet soepel en betrouwbaar loopt.
1.Motordomp, scheefstelling en aansluiten van de brandstofslangetjes.
2.Carburateurinstellingen en stelmogelijkheden, stationairafstelling.
3.Zenderbediening. De bediening kan niet vaak genoeg gecontroleerd worden. Bij een vliegtuig met rolroeren zal bij linksom sturen het linker rolroer omhoog gaan. Bij linksaf sturen zal het richtingsroer naar links uitslaan. Bij omhoog sturen zal het hoogteroer naar boven gaan.